enginehall 2.0.0__py3-none-any.whl

pcba/adapters/altium_bridge/bridge.pas

@@ -0,0 +1,3342 @@
+{ PCBA Studio - Altium Designer bridge library.                                   }
+{                                                                                  }
+{ The adapter (pcba/adapters/altium_drive.py) verifies this file's SHA-256, then   }
+{ appends a generated `Body` that calls only the procedures below with literal     }
+{ arguments, and a `Run` entry point, and runs the result with                     }
+{ ScriptingSystem:RunScriptFile. Nothing here parses a request: arguments arrive   }
+{ as Pascal literals the adapter has validated and escaped.                        }
+{                                                                                  }
+{ Rules this code follows, all measured on Altium Designer Develop 26.10:          }
+{ - integers only: German Windows formats floats with a comma;                     }
+{ - no `raise`: DelphiScript rejects it at parse time; ops call Fail() instead,    }
+{   and every op returns at once when an earlier op failed;                        }
+{ - the response goes to <exchange>\<id>.json via a temp file, so a late reply     }
+{   can never be read as the answer to another request;                            }
+{ - a new document joins the focused project, whichever that is: it is unbound    }
+{   from every other project and bound to its own.                                 }
+{                                                                                  }
+{ Portions follow patterns published in altium-mcp, Copyright (c) 2025 Siddharth   }
+{ Ahuja, MIT licence; see THIRD_PARTY_NOTICES.md.                                  }
+
+const
+    BRIDGE_VERSION = '1.6.0';
+    RA = 1;
+
+var
+    G_ID       : String;
+    G_DONE     : Boolean;
+    G_EX       : String;
+    FailS      : String;
+    ItemsS     : String;
+    CurOpName  : String;
+    CurOp      : Integer;
+    Ok         : Boolean;
+    LogSL      : TStringList;
+    CurSch     : ISch_Document;
+    CurSchDoc  : IServerDocument;
+    CurLib     : ISch_Lib;
+    CurLibDoc  : IServerDocument;
+    CurComp    : ISch_Component;
+    CurPcbLib  : IPCB_Library;
+    CurPcbLibDoc : IServerDocument;
+    CurFp      : IPCB_LibComponent;
+    CurBoard   : IPCB_Board;
+    CurBoardDoc : IServerDocument;
+    CurSheetSym : ISch_SheetSymbol;
+
+{ ---------------------------------------------------------------- plumbing --- }
+
+procedure Log(S: String);
+begin
+    LogSL.Add(FormatDateTime('hh:nn:ss.zzz', Now) + ' ' + S);
+    LogSL.SaveToFile(G_EX + G_ID + '.log');
+end;
+
+function J(S: String): String;
+var
+    I, C : Integer;
+    R    : String;
+begin
+    R := '';
+    for I := 1 to Length(S) do
+    begin
+        C := Ord(S[I]);
+        if C = 34 then R := R + '\"'
+        else if C = 92 then R := R + '\\'
+        else if C = 10 then R := R + '\n'
+        else if C = 13 then R := R + '\r'
+        else if C = 9 then R := R + '\t'
+        else if (C < 32) or (C > 126) then R := R + '\u' + IntToHex(C, 4)
+        else R := R + S[I];
+    end;
+    Result := R;
+end;
+
+function F(K, V: String): String;
+begin
+    Result := ',"' + K + '":"' + J(V) + '"';
+end;
+
+function FI(K: String; V: Integer): String;
+begin
+    Result := ',"' + K + '":' + IntToStr(V);
+end;
+
+function FB(K: String; V: Boolean): String;
+begin
+    if V then Result := ',"' + K + '":true' else Result := ',"' + K + '":false';
+end;
+
+procedure Fail(Msg: String);
+begin
+    if Ok then
+    begin
+        Ok := False;
+        FailS := Msg;
+    end;
+    Log('FAIL ' + Msg);
+end;
+
+procedure OpBegin(I: Integer; Name: String);
+begin
+    if not Ok then Exit;
+    CurOp := I;
+    CurOpName := Name;
+    Log('op ' + IntToStr(I) + ' ' + Name);
+end;
+
+procedure Emit(Fields: String);
+begin
+    if ItemsS <> '' then ItemsS := ItemsS + ',';
+    ItemsS := ItemsS + '{"op":' + IntToStr(CurOp) + ',"name":"' + CurOpName + '"' + Fields + '}';
+end;
+
+procedure Init(Id, Ex: String);
+begin
+    G_ID := Id;
+    G_EX := Ex;
+    Ok := True;
+    FailS := '';
+    ItemsS := '';
+    CurOp := -1;
+    CurOpName := '';
+    G_DONE := False;
+    LogSL := TStringList.Create;
+    Log('start bridge ' + BRIDGE_VERSION);
+end;
+
+procedure Finish(Err: String);
+var
+    SL   : TStringList;
+    Body : String;
+begin
+    if (Err <> '') then Fail(Err);
+    Body := '{"id":"' + G_ID + '","bridge":"' + BRIDGE_VERSION + '"' + FB('ok', Ok);
+    if not Ok then Body := Body + FI('failed_op', CurOp) + F('failed_name', CurOpName) + F('error', FailS);
+    Body := Body + ',"items":[' + ItemsS + ']}';
+    SL := TStringList.Create;
+    SL.Text := Body;
+    DeleteFile(G_EX + G_ID + '.tmp');
+    SL.SaveToFile(G_EX + G_ID + '.tmp');
+    SL.Free;
+    DeleteFile(G_EX + G_ID + '.json');
+    RenameFile(G_EX + G_ID + '.tmp', G_EX + G_ID + '.json');
+    Log('end ok=' + BoolToStr(Ok, True));
+end;
+
+procedure Done;
+begin
+    G_DONE := True;
+end;
+
+procedure Complete;
+begin
+    { Body ends with Done. Reaching here without it means an operation stopped the script
+      without raising anything: never report that as success. }
+    if G_DONE then Finish('')
+    else Finish('the script stopped inside this operation without an error message');
+end;
+
+function IntList(Csv: String): TStringList;
+begin
+    Result := TStringList.Create;
+    Result.Delimiter := ',';
+    Result.StrictDelimiter := True;
+    Result.DelimitedText := Csv;
+end;
+
+{ ------------------------------------------------------- workspace / documents --- }
+
+function FindProject(Path: String): IProject;
+var
+    WS : IWorkspace;
+    I  : Integer;
+begin
+    Result := nil;
+    WS := GetWorkspace;
+    for I := 0 to WS.DM_ProjectCount - 1 do
+        if SameText(WS.DM_Projects(I).DM_ProjectFullPath, Path) then Result := WS.DM_Projects(I);
+end;
+
+procedure CloseDocPath(Path: String; Save: Boolean);
+var
+    SD : IServerDocument;
+begin
+    { Closing a modified document raises Altium's "Unsaved Changes" dialog, which blocks the
+      script. Save or discard explicitly first so it can never appear. }
+    SD := Client.GetDocumentByPath(Path);
+    if (SD <> nil) and SD.Modified then
+    begin
+        if Save then SD.DoFileSave('') else SD.SetModified(False);
+    end;
+    ResetParameters;
+    AddStringParameter('ObjectKind', 'Document');
+    AddStringParameter('FileName', Path);
+    RunProcess('WorkspaceManager:CloseObject');
+end;
+
+function ShowDoc(Kind, Path: String): IServerDocument;
+begin
+    Result := Client.OpenDocument(Kind, Path);
+    if Result <> nil then Client.ShowDocument(Result);
+end;
+
+procedure ProjectOpen(Path: String);
+var
+    Prj : IProject;
+begin
+    if not Ok then Exit;
+    if not FileExists(Path) then begin Fail('project file not found: ' + Path); Exit; end;
+    Prj := FindProject(Path);
+    if Prj = nil then
+    begin
+        ResetParameters;
+        AddStringParameter('ObjectKind', 'Project');
+        AddStringParameter('FileName', Path);
+        RunProcess('WorkspaceManager:OpenObject');
+        Prj := FindProject(Path);
+    end;
+    if Prj = nil then begin Fail('Altium did not open the project: ' + Path); Exit; end;
+    Prj.DM_SetAsCurrentProject;
+    Emit(F('project', Path) + FI('documents', Prj.DM_LogicalDocumentCount));
+end;
+
+function InOtherProject(DocPath, PrjPath: String): Boolean;
+var
+    WS  : IWorkspace;
+    Prj : IProject;
+    I, K: Integer;
+begin
+    Result := False;
+    WS := GetWorkspace;
+    for K := 0 to WS.DM_ProjectCount - 1 do
+    begin
+        Prj := WS.DM_Projects(K);
+        if not SameText(Prj.DM_ProjectFullPath, PrjPath) then
+            for I := 0 to Prj.DM_LogicalDocumentCount - 1 do
+                if SameText(Prj.DM_LogicalDocuments(I).DM_FullPath, DocPath) then Result := True;
+    end;
+end;
+
+procedure ProjectClose(Path: String; SaveAll: Boolean);
+var
+    SD     : IServerDocument;
+    Prj    : IProject;
+    I      : Integer;
+    Loaded : TStringList;
+    Shared : TStringList;
+    Left   : String;
+begin
+    if not Ok then Exit;
+    Prj := FindProject(Path);
+    if Prj = nil then begin Emit(FB('closed', True)); Exit; end;
+    { CloseObject acts on the focused project, whatever FileName says: focus this one first.
+      SaveAll saves the project and every loaded document first, so no "Unsaved Changes" prompt
+      can appear (a PCB's Modified flag can read False after an ECO, so loaded documents are
+      saved regardless). Without SaveAll nothing is saved: Altium asks about each modified
+      document ("Unsaved Changes", or "Confirm Save to Server" in an Altium 365 working copy)
+      and the drive answers by the request's answer policy, or cancels, which fails below. }
+    Prj.DM_SetAsCurrentProject;
+    Loaded := TStringList.Create;
+    Shared := TStringList.Create;
+    for I := 0 to Prj.DM_LogicalDocumentCount - 1 do
+    begin
+        SD := Client.GetDocumentByPath(Prj.DM_LogicalDocuments(I).DM_FullPath);
+        if SD <> nil then
+        begin
+            Loaded.Add(Prj.DM_LogicalDocuments(I).DM_FullPath);
+            { A library another open project also lists stays open legitimately. }
+            if InOtherProject(Prj.DM_LogicalDocuments(I).DM_FullPath, Path) then
+                Shared.Add(Prj.DM_LogicalDocuments(I).DM_FullPath);
+            if SaveAll then
+            begin
+                SD.SetModified(True);
+                SD.DoFileSave('');
+            end;
+        end;
+    end;
+    SD := Client.GetDocumentByPath(Path);
+    if (SD <> nil) and SaveAll then
+    begin
+        { Modified can read False while Altium still holds unsaved project state. }
+        SD.SetModified(True);
+        SD.DoFileSave('');
+    end;
+    ResetParameters;
+    AddStringParameter('ObjectKind', 'Project');
+    AddStringParameter('FileName', Path);
+    RunProcess('WorkspaceManager:CloseObject');
+    { A document that refuses to close does not stay with the closed project: Altium hands it
+      to another open project or leaves it free, and it later breaks an ECO. Only documents
+      another project listed before the close may stay open; fail on any other. }
+    Left := '';
+    for I := 0 to Loaded.Count - 1 do
+        if (Client.GetDocumentByPath(Loaded[I]) <> nil) and (Shared.IndexOf(Loaded[I]) < 0) then
+            Left := Left + Loaded[I] + '; ';
+    Loaded.Free;
+    Shared.Free;
+    if FindProject(Path) <> nil then
+    begin
+        Fail('project stayed open (a prompt was cancelled or refused?): ' + Path);
+        Exit;
+    end;
+    if Left <> '' then begin Fail('documents stayed open after closing the project: ' + Left); Exit; end;
+    Emit(FB('closed', True) + FB('saved', SaveAll));
+end;
+
+procedure ProjectState(Path: String);
+var
+    WS       : IWorkspace;
+    Prj      : IProject;
+    D        : IDocument;
+    SD       : IServerDocument;
+    I        : Integer;
+    Folder   : String;
+    Loaded   : Boolean;
+    Modified : Boolean;
+begin
+    { Path '' lists the open projects; a project path lists its documents with what Altium holds
+      in memory (loaded, modified) and what is on disk (exists, inside the project folder). }
+    if not Ok then Exit;
+    WS := GetWorkspace;
+    if Path = '' then
+    begin
+        Folder := '';
+        if WS.DM_FocusedProject <> nil then Folder := WS.DM_FocusedProject.DM_ProjectFullPath;
+        for I := 0 to WS.DM_ProjectCount - 1 do
+        begin
+            Prj := WS.DM_Projects(I);
+            Emit(F('kind', 'project') + F('project', Prj.DM_ProjectFullPath)
+                + FI('documents', Prj.DM_LogicalDocumentCount)
+                + FB('current', SameText(Prj.DM_ProjectFullPath, Folder)));
+        end;
+        Exit;
+    end;
+    Prj := FindProject(Path);
+    if Prj = nil then begin Emit(F('kind', 'project') + F('project', Path) + FB('open', False)); Exit; end;
+    Folder := ExtractFilePath(Path);
+    for I := 0 to Prj.DM_LogicalDocumentCount - 1 do
+    begin
+        D := Prj.DM_LogicalDocuments(I);
+        SD := Client.GetDocumentByPath(D.DM_FullPath);
+        Loaded := SD <> nil;
+        Modified := False;
+        if Loaded then Modified := SD.Modified;
+        Emit(F('kind', 'document') + F('path', D.DM_FullPath) + F('doc_kind', D.DM_DocumentKind)
+            + FB('loaded', Loaded) + FB('modified', Modified) + FB('exists', FileExists(D.DM_FullPath))
+            + FB('inside', SameText(Copy(D.DM_FullPath, 1, Length(Folder)), Folder)));
+    end;
+    SD := Client.GetDocumentByPath(Path);
+    Modified := False;
+    if SD <> nil then Modified := SD.Modified;
+    Emit(F('kind', 'project') + F('project', Path) + FB('open', True) + FB('modified', Modified)
+        + FI('documents', Prj.DM_LogicalDocumentCount));
+end;
+
+procedure ProjectSave(Path: String);
+var
+    SD : IServerDocument;
+begin
+    if not Ok then Exit;
+    if FindProject(Path) = nil then begin Fail('project not open: ' + Path); Exit; end;
+    SD := Client.GetDocumentByPath(Path);
+    if SD = nil then begin Fail('Altium has no server document for ' + Path); Exit; end;
+    SD.SetModified(True);
+    Emit(F('project', Path) + FB('saved', SD.DoFileSave('')));
+end;
+
+procedure BindToProject(DocPath, PrjPath: String);
+var
+    Prj, Free : IProject;
+    I         : Integer;
+    Found     : Boolean;
+begin
+    Prj := FindProject(PrjPath);
+    if Prj = nil then begin Fail('project not open: ' + PrjPath); Exit; end;
+    Free := GetWorkspace.DM_FreeDocumentsProject;
+    if Free <> nil then
+        for I := Free.DM_LogicalDocumentCount - 1 downto 0 do
+            if SameText(Free.DM_LogicalDocuments(I).DM_FullPath, DocPath) then
+            begin
+                { A free document must be saved and closed before a project can own it. }
+                CloseDocPath(DocPath, True);
+                Free.DM_RemoveSourceDocument(DocPath);
+            end;
+    Found := False;
+    for I := 0 to Prj.DM_LogicalDocumentCount - 1 do
+        if SameText(Prj.DM_LogicalDocuments(I).DM_FullPath, DocPath) then Found := True;
+    if not Found then Prj.DM_AddSourceDocument(DocPath);
+end;
+
+function UnbindElsewhere(DocPath, PrjPath: String): Integer;
+var
+    WS       : IWorkspace;
+    Prj      : IProject;
+    I, K     : Integer;
+    FreePath : String;
+begin
+    { DM_CreateNewDocument adds the new document to the focused project, which is the project of
+      the document in front (another project's library left open by an earlier request), not
+      the current one. The new document belongs to PrjPath alone (or to none): remove it from
+      every other project before any of them is saved with it. }
+    Result := 0;
+    WS := GetWorkspace;
+    FreePath := '';
+    if WS.DM_FreeDocumentsProject <> nil then FreePath := WS.DM_FreeDocumentsProject.DM_ProjectFullPath;
+    for K := 0 to WS.DM_ProjectCount - 1 do
+    begin
+        Prj := WS.DM_Projects(K);
+        if not SameText(Prj.DM_ProjectFullPath, FreePath) and not SameText(Prj.DM_ProjectFullPath, PrjPath) then
+            for I := Prj.DM_LogicalDocumentCount - 1 downto 0 do
+                if SameText(Prj.DM_LogicalDocuments(I).DM_FullPath, DocPath) then
+                begin
+                    Prj.DM_RemoveSourceDocument(DocPath);
+                    Log('unbound ' + DocPath + ' from ' + Prj.DM_ProjectFullPath);
+                    Result := Result + 1;
+                end;
+    end;
+end;
+
+procedure DocCreate(Kind, Path, PrjPath: String);
+var
+    SD      : IServerDocument;
+    Prj     : IProject;
+    Unbound : Integer;
+begin
+    if not Ok then Exit;
+    if FileExists(Path) then
+    begin
+        { Existing document: only bind it. Closing an open document can raise a deferred
+          "Unsaved Changes" prompt after the script has returned. }
+        if PrjPath <> '' then BindToProject(Path, PrjPath);
+        Emit(F('path', Path) + FB('created', False));
+        Exit;
+    end;
+    if PrjPath <> '' then
+    begin
+        Prj := FindProject(PrjPath);
+        if Prj = nil then begin Fail('project not open: ' + PrjPath); Exit; end;
+        Prj.DM_SetAsCurrentProject;
+    end;
+    GetWorkSpace.DM_CreateNewDocument(Kind);
+    SD := Client.CurrentView.OwnerDocument;
+    if SD = nil then begin Fail('Altium created no ' + Kind + ' document'); Exit; end;
+    SD.SetFileName(Path);
+    SD.DoFileSave('');
+    CloseDocPath(Path, True);
+    if not FileExists(Path) then begin Fail('new document was not written: ' + Path); Exit; end;
+    if PrjPath <> '' then BindToProject(Path, PrjPath);
+    if not Ok then Exit;
+    Unbound := UnbindElsewhere(Path, PrjPath);
+    Emit(F('path', Path) + FB('created', True) + FI('unbound', Unbound));
+end;
+
+procedure DocSave(Path: String);
+var
+    SD : IServerDocument;
+begin
+    if not Ok then Exit;
+    SD := Client.GetDocumentByPath(Path);
+    if SD = nil then begin Fail('document not open: ' + Path); Exit; end;
+    SD.SetModified(True);
+    Emit(F('path', Path) + FB('saved', SD.DoFileSave('')));
+end;
+
+procedure DocClose(Path: String; Save: Boolean);
+begin
+    if not Ok then Exit;
+    CloseDocPath(Path, Save);
+    Emit(F('path', Path) + FB('closed', Client.GetDocumentByPath(Path) = nil));
+end;
+
+procedure DocFocus(Kind, Path: String; ZoomProcess: String);
+var
+    SD : IServerDocument;
+begin
+    if not Ok then Exit;
+    SD := ShowDoc(Kind, Path);
+    if SD = nil then begin Fail('cannot open ' + Path); Exit; end;
+    { A PCB zooms to the board shape: Action=All would include parts parked off the board. }
+    if ZoomProcess = 'PCB:Zoom' then
+        Client.SendMessage(ZoomProcess, 'Action=Board', 255, Client.CurrentView)
+    else if ZoomProcess <> '' then
+        Client.SendMessage(ZoomProcess, 'Action=All', 255, Client.CurrentView);
+    Emit(F('path', Path));
+end;
+
+procedure EmitViolation(V: IViolation);
+var
+    K : Integer;
+    O : IDMObject;
+    S : String;
+begin
+    { The descriptor alone names the kind of message ("Net has no driving source") but not
+      where. The related objects carry the net, pin, port or part and the sheet it is on,
+      which is what someone fixing the warning needs. At most 8 per violation. }
+    S := '';
+    for K := 0 to V.DM_RelatedObjectCount - 1 do
+        if K < 8 then
+        begin
+            O := V.DM_RelatedObjects(K);
+            if S <> '' then S := S + ',';
+            S := S + '{"kind":"' + J(O.DM_ObjectKindString) + '","text":"' + J(O.DM_LongDescriptorString)
+                + '","document":"' + J(O.DM_OwnerDocumentName) + '"}';
+        end;
+    Emit(F('kind', 'violation') + F('text', V.DM_LongDescriptorString) + FI('level', V.DM_ErrorLevel)
+        + ',"objects":[' + S + ']');
+end;
+
+procedure ProjectNetlist(PrjPath: String; Reopen: Boolean);
+var
+    Prj      : IProject;
+    Flat     : IDocument;
+    Net      : INet;
+    Pin      : IPin;
+    Comp     : IComponent;
+    I, K     : Integer;
+    S        : String;
+    HasSheet : Boolean;
+begin
+    if not Ok then Exit;
+    Prj := FindProject(PrjPath);
+    if Prj = nil then begin Fail('project not open: ' + PrjPath); Exit; end;
+    if Reopen then
+    begin
+        { Scripted sheet edits do not refresh the compiler's model: once a project has compiled
+          components, later compiles in the session keep returning that first state (measured:
+          sheets 2 and 3 of a project drawn sheet by sheet never reached the netlist). Only
+          closing and reopening the project makes Altium compile the saved sheets. The close
+          saves every document first; only an approved apply passes Reopen. }
+        Log('netlist: closing and reopening the project for a fresh compile');
+        ProjectClose(PrjPath, True);
+        ProjectOpen(PrjPath);
+        if not Ok then Exit;
+        Prj := FindProject(PrjPath);
+        if Prj = nil then begin Fail('project did not reopen: ' + PrjPath); Exit; end;
+    end;
+    { Measured: compiling a just-created project while another one held the focus returned no
+      nets and no messages. Focus the project being compiled first. }
+    Prj.DM_SetAsCurrentProject;
+    Prj.DM_Compile;
+    Flat := Prj.DM_DocumentFlattened;
+    if (Flat = nil) or (Flat.DM_NetCount = 0) then
+    begin
+        { The first compile after documents were bound to a new project can come back empty. }
+        Prj.DM_Compile;
+        Flat := Prj.DM_DocumentFlattened;
+    end;
+    HasSheet := False;
+    for I := 0 to Prj.DM_LogicalDocumentCount - 1 do
+        if SameText(Prj.DM_LogicalDocuments(I).DM_DocumentKind, 'SCH') then HasSheet := True;
+    if HasSheet and ((Flat = nil) or (Flat.DM_ComponentCount = 0)) and not Reopen then
+        { A read never reopens: closing saves every document of the project. }
+        Emit(F('kind', 'warning') + F('text', 'no components compiled from a project with sheets: empty sheets, '
+            + 'or the project is stale in memory; altium_netlist or altium_verify with fresh: true compiles '
+            + 'the saved sheets'));
+    if Flat = nil then begin Fail('Altium produced no flattened netlist'); Exit; end;
+    for I := 0 to Flat.DM_NetCount - 1 do
+    begin
+        Net := Flat.DM_Nets(I);
+        S := '';
+        for K := 0 to Net.DM_PinCount - 1 do
+        begin
+            Pin := Net.DM_Pins(K);
+            if S <> '' then S := S + ',';
+            S := S + '["' + J(Pin.DM_LogicalPartDesignator) + '","' + J(Pin.DM_PinNumber) + '"]';
+        end;
+        Emit(F('kind', 'net') + F('net', Net.DM_NetName) + ',"pins":[' + S + ']');
+    end;
+    for I := 0 to Flat.DM_ComponentCount - 1 do
+    begin
+        Comp := Flat.DM_Components(I);
+        Emit(F('kind', 'component') + F('designator', Comp.DM_LogicalDesignator)
+            + F('lib_ref', Comp.DM_LibraryReference) + F('comment', Comp.DM_Comment)
+            + F('footprint', Comp.DM_Footprint));
+    end;
+    for I := 0 to Prj.DM_ViolationCount - 1 do
+        if I < 300 then EmitViolation(Prj.DM_Violations(I));
+    Emit(F('kind', 'summary') + FI('violations', Prj.DM_ViolationCount) + FI('nets', Flat.DM_NetCount)
+        + FI('components', Flat.DM_ComponentCount));
+end;
+
+{ ------------------------------------------------------------ symbol library --- }
+
+procedure SymBegin(Lib, Name, Desc, Prefix, Comment, Footprint: String; PartCount: Integer);
+var
+    It   : ISch_Iterator;
+    C    : ISch_Component;
+    Impl : ISch_Implementation;
+begin
+    if not Ok then Exit;
+    CurLibDoc := ShowDoc('SCHLIB', Lib);
+    if CurLibDoc = nil then begin Fail('cannot open symbol library ' + Lib); Exit; end;
+    CurLib := SchServer.GetSchDocumentByPath(Lib);
+    if (CurLib = nil) or (CurLib.ObjectID <> eSchLib) then begin Fail('not a symbol library: ' + Lib); Exit; end;
+    It := CurLib.SchLibIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eSchComponent));
+    C := It.FirstSchObject;
+    while C <> nil do
+    begin
+        if SameText(C.LibReference, Name) then
+        begin
+            CurLib.RemoveSchComponent(C);
+            Log('replaced existing symbol ' + Name);
+            C := nil;
+        end
+        else C := It.NextSchObject;
+    end;
+    CurLib.SchIterator_Destroy(It);
+    CurComp := SchServer.SchObjectFactory(eSchComponent, eCreate_Default);
+    CurComp.CurrentPartID := 1;
+    CurComp.DisplayMode := 0;
+    CurComp.PartCount := PartCount;
+    CurComp.LibReference := Name;
+    CurComp.ComponentDescription := Desc;
+    CurComp.Designator.Text := Prefix + '?';
+    CurComp.Comment.Text := Comment;
+    if Footprint <> '' then
+    begin
+        Impl := CurComp.AddSchImplementation;
+        Impl.ModelName := Footprint;
+        Impl.ModelType := 'PCBLIB';
+        Impl.IsCurrent := True;
+    end;
+end;
+
+procedure SymPin(Num, Name: String; Elec, X, Y, Orient, Len, Part: Integer; ShowName, Hidden: Boolean);
+var
+    P : ISch_Pin;
+begin
+    if not Ok then Exit;
+    P := SchServer.SchObjectFactory(ePin, eCreate_Default);
+    P.Designator := Num;
+    P.Name := Name;
+    P.Electrical := Elec;
+    P.Orientation := Orient;
+    P.Location := Point(MilsToCoord(X), MilsToCoord(Y));
+    P.PinLength := MilsToCoord(Len);
+    P.ShowName := ShowName;
+    P.IsHidden := Hidden;
+    P.OwnerPartId := Part;
+    P.OwnerPartDisplayMode := 0;
+    CurComp.AddSchObject(P);
+end;
+
+procedure SymRect(X1, Y1, X2, Y2, Part: Integer);
+var
+    R : ISch_Rectangle;
+begin
+    if not Ok then Exit;
+    R := SchServer.SchObjectFactory(eRectangle, eCreate_Default);
+    R.Location := Point(MilsToCoord(X1), MilsToCoord(Y1));
+    R.Corner := Point(MilsToCoord(X2), MilsToCoord(Y2));
+    R.LineWidth := eSmall;
+    R.IsSolid := True;
+    R.AreaColor := $00B0FFFF;
+    R.Color := $00800000;
+    R.OwnerPartId := Part;
+    R.OwnerPartDisplayMode := 0;
+    CurComp.AddSchObject(R);
+end;
+
+procedure SymLine(X1, Y1, X2, Y2, Part: Integer);
+var
+    L : ISch_Line;
+begin
+    if not Ok then Exit;
+    L := SchServer.SchObjectFactory(eLine, eCreate_Default);
+    L.Location := Point(MilsToCoord(X1), MilsToCoord(Y1));
+    L.Corner := Point(MilsToCoord(X2), MilsToCoord(Y2));
+    L.LineWidth := eSmall;
+    L.Color := $00800000;
+    L.OwnerPartId := Part;
+    L.OwnerPartDisplayMode := 0;
+    CurComp.AddSchObject(L);
+end;
+
+procedure SymText(Text: String; X, Y, Part: Integer);
+var
+    L : ISch_Label;
+begin
+    if not Ok then Exit;
+    L := SchServer.SchObjectFactory(eLabel, eCreate_Default);
+    L.Location := Point(MilsToCoord(X), MilsToCoord(Y));
+    L.Text := Text;
+    L.OwnerPartId := Part;
+    L.OwnerPartDisplayMode := 0;
+    CurComp.AddSchObject(L);
+end;
+
+procedure SymParam(Name, Value: String; Visible: Boolean);
+var
+    P : ISch_Parameter;
+begin
+    if not Ok then Exit;
+    P := SchServer.SchObjectFactory(eParameter, eCreate_Default);
+    P.Name := Name;
+    P.Text := Value;
+    P.IsHidden := not Visible;
+    CurComp.AddSchObject(P);
+end;
+
+procedure SymEnd;
+var
+    Pins : Integer;
+    It   : ISch_Iterator;
+    O    : ISch_GraphicalObject;
+begin
+    if not Ok then Exit;
+    CurLib.AddSchComponent(CurComp);
+    SchServer.RobotManager.SendMessage(nil, c_BroadCast, SCHM_PrimitiveRegistration, CurComp.I_ObjectAddress);
+    CurLib.CurrentSchComponent := CurComp;
+    CurLib.GraphicallyInvalidate;
+    Pins := 0;
+    It := CurComp.SchIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(ePin));
+    O := It.FirstSchObject;
+    while O <> nil do begin Pins := Pins + 1; O := It.NextSchObject; end;
+    CurComp.SchIterator_Destroy(It);
+    CurLibDoc.SetModified(True);
+    CurLibDoc.DoFileSave('');
+    Emit(F('symbol', CurComp.LibReference) + FI('pins', Pins));
+end;
+
+{ --------------------------------------------------------- footprint library --- }
+
+procedure FpBegin(Lib, Name, Desc: String; Height: Integer);
+var
+    Old : IPCB_LibComponent;
+begin
+    if not Ok then Exit;
+    CurPcbLibDoc := ShowDoc('PCBLIB', Lib);
+    if CurPcbLibDoc = nil then begin Fail('cannot open footprint library ' + Lib); Exit; end;
+    CurPcbLib := PCBServer.GetCurrentPCBLibrary;
+    if CurPcbLib = nil then begin Fail('not a footprint library: ' + Lib); Exit; end;
+    if not SameText(CurPcbLib.Board.FileName, Lib) then begin Fail('Altium focused another library: ' + CurPcbLib.Board.FileName); Exit; end;
+    Old := CurPcbLib.GetComponentByName(Name);
+    if Old <> nil then
+    begin
+        CurPcbLib.RemoveComponent(Old);
+        Log('replaced existing footprint ' + Name);
+    end;
+    CurFp := PCBServer.CreatePCBLibComp;
+    CurFp.Name := Name;
+    CurFp.Description := Desc;
+    CurFp.Height := Height;
+    CurPcbLib.RegisterComponent(CurFp);
+    PCBServer.PreProcess;
+end;
+
+procedure FpPad(Name: String; X, Y, Shape, W, H, Rot, Layer, Hole: Integer; Plated: Boolean; CornerPct: Integer;
+    MaskManual: Boolean; MaskExp: Integer; Paste: Boolean);
+var
+    P : IPCB_Pad;
+    C : TPadCache;
+begin
+    if not Ok then Exit;
+    P := PCBServer.PCBObjectFactory(ePadObject, eNoDimension, eCreate_Default);
+    P.Name := Name;
+    P.Mode := ePadMode_Simple;
+    P.x := X;
+    P.y := Y;
+    P.Layer := Layer;
+    P.HoleSize := Hole;
+    P.Plated := Plated;
+    P.TopShape := Shape;
+    P.TopXSize := W;
+    P.TopYSize := H;
+    P.MidShape := Shape;
+    P.MidXSize := W;
+    P.MidYSize := H;
+    P.BotShape := Shape;
+    P.BotXSize := W;
+    P.BotYSize := H;
+    if Shape = eRoundedRectangular then P.SetState_StackCRPctOnLayer(eTopLayer, CornerPct);
+    P.Rotation := Rot;
+    CurFp.AddPCBObject(P);
+    PCBServer.SendMessageToRobots(P.I_ObjectAddress, c_Broadcast, PCBM_BoardRegisteration, c_NoEventData);
+    { Manual mask and paste expansions go through the pad cache: writing P.SolderMaskExpansion
+      directly is an access violation inside Altium's scripting system. No paste is a manual paste
+      expansion that shrinks the aperture to nothing. }
+    if MaskManual or (not Paste) then
+    begin
+        PCBServer.SendMessageToRobots(P.I_ObjectAddress, c_Broadcast, PCBM_BeginModify, c_NoEventData);
+        C := P.GetState_Cache;
+        if MaskManual then
+        begin
+            C.SolderMaskExpansion := MaskExp;
+            C.SolderMaskExpansionValid := eCacheManual;
+        end;
+        if not Paste then
+        begin
+            C.PasteMaskExpansion := -(W + H);
+            C.PasteMaskExpansionValid := eCacheManual;
+        end;
+        P.SetState_Cache := C;
+        PCBServer.SendMessageToRobots(P.I_ObjectAddress, c_Broadcast, PCBM_EndModify, c_NoEventData);
+    end;
+end;
+
+procedure FpTrack(Layer, X1, Y1, X2, Y2, W: Integer);
+var
+    T : IPCB_Track;
+begin
+    if not Ok then Exit;
+    T := PCBServer.PCBObjectFactory(eTrackObject, eNoDimension, eCreate_Default);
+    T.x1 := X1; T.y1 := Y1; T.x2 := X2; T.y2 := Y2;
+    T.Layer := Layer;
+    T.Width := W;
+    CurFp.AddPCBObject(T);
+end;
+
+procedure FpArc(Layer, XC, YC, R, A1, A2, W: Integer);
+var
+    A : IPCB_Arc;
+begin
+    if not Ok then Exit;
+    A := PCBServer.PCBObjectFactory(eArcObject, eNoDimension, eCreate_Default);
+    A.XCenter := XC; A.YCenter := YC; A.Radius := R;
+    A.StartAngle := A1; A.EndAngle := A2;
+    A.Layer := Layer;
+    A.LineWidth := W;
+    CurFp.AddPCBObject(A);
+end;
+
+procedure FpBody(Csv: String; Standoff, Height, Layer: Integer);
+var
+    B   : IPCB_ComponentBody;
+    C   : IPCB_Contour;
+    M   : IPCB_Model;
+    SL  : TStringList;
+    I   : Integer;
+begin
+    if not Ok then Exit;
+    SL := IntList(Csv);
+    B := PCBServer.PCBObjectFactory(eComponentBodyObject, eNoDimension, eCreate_Default);
+    C := PCBServer.PCBContourFactory;
+    for I := 0 to (SL.Count div 2) - 1 do
+        C.AddPoint(StrToInt(SL[2 * I]), StrToInt(SL[2 * I + 1]));
+    B.SetOutlineContour(C);
+    B.Layer := Layer;
+    B.BodyProjection := eBoardSide_Top;
+    M := B.ModelFactory_CreateExtruded(Standoff, Height, $00808080);
+    B.SetModel(M);
+    CurFp.AddPCBObject(B);
+    SL.Free;
+end;
+
+procedure FpModel(Path: String; RX, RY, RZ, DX, DY, DZ, Layer: Integer);
+var
+    B : IPCB_ComponentBody;
+    M : IPCB_Model;
+begin
+    { A STEP model, embedded so the library carries it. Altium rotates it about its own origin
+      (X, Y, then Z), lifts it by DZ, and the body is then moved by DX, DY. }
+    if not Ok then Exit;
+    if not FileExists(Path) then begin Fail('STEP model not found: ' + Path); Exit; end;
+    B := PCBServer.PCBObjectFactory(eComponentBodyObject, eNoDimension, eCreate_Default);
+    M := B.ModelFactory_FromFilename(Path, True);
+    if M = nil then begin Fail('Altium could not read the STEP model ' + Path); Exit; end;
+    M.SetState(RX, RY, RZ, DZ);
+    B.SetState_FromModel;
+    B.SetModel(M);
+    B.Layer := Layer;
+    B.BodyProjection := eBoardSide_Top;
+    B.MoveByXY(DX, DY);
+    CurFp.AddPCBObject(B);
+    Emit(F('model', Path) + FI('overall', B.OverallHeight) + FI('standoff', B.StandoffHeight));
+end;
+
+procedure FpEnd;
+var
+    It : IPCB_GroupIterator;
+    O  : IPCB_Primitive;
+    N  : Integer;
+begin
+    if not Ok then Exit;
+    PCBServer.PostProcess;
+    PCBServer.SendMessageToRobots(CurPcbLib.Board.I_ObjectAddress, c_Broadcast, PCBM_BoardRegisteration, CurFp.I_ObjectAddress);
+    CurPcbLib.CurrentComponent := CurFp;
+    CurPcbLib.Board.ViewManager_FullUpdate;
+    N := 0;
+    It := CurFp.GroupIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(ePadObject));
+    O := It.FirstPCBObject;
+    while O <> nil do begin N := N + 1; O := It.NextPCBObject; end;
+    CurFp.GroupIterator_Destroy(It);
+    CurPcbLibDoc.SetModified(True);
+    CurPcbLibDoc.DoFileSave('');
+    Emit(F('footprint', CurFp.Name) + FI('pads', N));
+end;
+
+{ ---------------------------------------------------------------- schematic --- }
+
+procedure SchOpen(Path: String);
+begin
+    if not Ok then Exit;
+    CurSchDoc := ShowDoc('SCH', Path);
+    if CurSchDoc = nil then begin Fail('cannot open schematic ' + Path); Exit; end;
+    CurSch := SchServer.GetSchDocumentByPath(Path);
+    if (CurSch = nil) or (CurSch.ObjectID <> eSheet) then begin Fail('not a schematic: ' + Path); Exit; end;
+    Emit(F('sheet', Path));
+end;
+
+function FindSchComp(Des: String): ISch_Component;
+var
+    It : ISch_Iterator;
+    C  : ISch_Component;
+begin
+    Result := nil;
+    It := CurSch.SchIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eSchComponent));
+    C := It.FirstSchObject;
+    while C <> nil do
+    begin
+        if SameText(C.Designator.Text, Des) then Result := C;
+        C := It.NextSchObject;
+    end;
+    CurSch.SchIterator_Destroy(It);
+end;
+
+function SchParts(Des: String; Part: Integer): TInterfaceList;
+var
+    It : ISch_Iterator;
+    C  : ISch_Component;
+begin
+    { Every placed part of a component on the current sheet. The parts of a multi-part
+      component are separate objects sharing the designator, told apart by CurrentPartID
+      (each carries every pin; the part id selects which ones are active). Part 0: all. }
+    Result := TInterfaceList.Create;
+    It := CurSch.SchIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eSchComponent));
+    C := It.FirstSchObject;
+    while C <> nil do
+    begin
+        if SameText(C.Designator.Text, Des) and ((Part = 0) or (C.CurrentPartID = Part)) then Result.Add(C);
+        C := It.NextSchObject;
+    end;
+    CurSch.SchIterator_Destroy(It);
+end;
+
+function OnePart(Des: String; Part: Integer): ISch_Component;
+var
+    L : TInterfaceList;
+begin
+    { The one part an operation acts on: Part 0 is accepted only when the designator has a
+      single part on the sheet, so an edit never lands on an arbitrary part. }
+    Result := nil;
+    L := SchParts(Des, Part);
+    if L.Count = 0 then
+    begin
+        if Part = 0 then Fail('no component ' + Des + ' on the sheet')
+        else Fail('no part ' + IntToStr(Part) + ' of ' + Des + ' on the sheet');
+    end
+    else if L.Count > 1 then
+    begin
+        if Part = 0 then Fail(Des + ' has ' + IntToStr(L.Count) + ' parts on this sheet: give part')
+        else Fail(Des + ' part ' + IntToStr(Part) + ' is placed ' + IntToStr(L.Count) + ' times on this sheet');
+    end
+    else Result := L.Items[0];
+    L.Free;
+end;
+
+procedure SchClear;
+var
+    It   : ISch_Iterator;
+    O    : ISch_GraphicalObject;
+    L    : TInterfaceList;
+    I    : Integer;
+begin
+    if not Ok then Exit;
+    L := TInterfaceList.Create;
+    It := CurSch.SchIterator_Create;
+    It.SetState_IterationDepth(eIterateFirstLevel);
+    It.AddFilter_ObjectSet(MkSet(eSchComponent, eWire, eNetLabel, ePowerObject, eNoERC, eJunction,
+        eLabel, eBus, eBusEntry, ePort, eLine, eRectangle, eNote, eTextFrame, eSheetSymbol));
+    O := It.FirstSchObject;
+    while O <> nil do begin L.Add(O); O := It.NextSchObject; end;
+    CurSch.SchIterator_Destroy(It);
+    SchServer.ProcessControl.PreProcess(CurSch, '');
+    for I := 0 to L.Count - 1 do CurSch.RemoveSchObject(L.Items[I]);
+    SchServer.ProcessControl.PostProcess(CurSch, '');
+    CurSch.GraphicallyInvalidate;
+    Emit(FI('removed', L.Count));
+end;
+
+procedure SchClearWiring;
+var
+    It   : ISch_Iterator;
+    O    : ISch_GraphicalObject;
+    L    : TInterfaceList;
+    I    : Integer;
+begin
+    { Like SchClear, but the components stay: their UniqueIDs, parameters and links to the PCB
+      survive, so a sheet can be redrawn without the board seeing new parts. }
+    if not Ok then Exit;
+    L := TInterfaceList.Create;
+    It := CurSch.SchIterator_Create;
+    It.SetState_IterationDepth(eIterateFirstLevel);
+    It.AddFilter_ObjectSet(MkSet(eWire, eNetLabel, ePowerObject, eNoERC, eJunction, eLabel, eBus, eBusEntry,
+        ePort, eLine));
+    O := It.FirstSchObject;
+    while O <> nil do begin L.Add(O); O := It.NextSchObject; end;
+    CurSch.SchIterator_Destroy(It);
+    SchServer.ProcessControl.PreProcess(CurSch, '');
+    for I := 0 to L.Count - 1 do CurSch.RemoveSchObject(L.Items[I]);
+    SchServer.ProcessControl.PostProcess(CurSch, '');
+    CurSch.GraphicallyInvalidate;
+    Emit(FI('removed', L.Count));
+end;
+
+procedure SchMove(Des: String; X, Y, Orient: Integer; Mirror: Boolean; Part: Integer);
+var
+    C : ISch_Component;
+begin
+    { Moves and turns a placed component without replacing it, so it keeps its UniqueID and
+      its link to the PCB (SchPlace replaces the part and the board would see a new one). }
+    if not Ok then Exit;
+    C := OnePart(Des, Part);
+    if C = nil then Exit;
+    SchServer.RobotManager.SendMessage(C.I_ObjectAddress, c_BroadCast, SCHM_BeginModify, c_NoEventData);
+    C.MoveToXY(MilsToCoord(X), MilsToCoord(Y));
+    C.Orientation := Orient;
+    C.IsMirrored := Mirror;
+    SchServer.RobotManager.SendMessage(C.I_ObjectAddress, c_BroadCast, SCHM_EndModify, c_NoEventData);
+    C.GraphicallyInvalidate;
+    Emit(F('designator', Des) + FI('part', C.CurrentPartID) + FI('x', X) + FI('y', Y) + FB('mirrored', Mirror));
+end;
+
+procedure PlaceText(P: ISch_Parameter; X, Y: Integer);
+begin
+    SchServer.RobotManager.SendMessage(P.I_ObjectAddress, c_BroadCast, SCHM_BeginModify, c_NoEventData);
+    P.Orientation := eRotate0;
+    P.Location := Point(MilsToCoord(X), MilsToCoord(Y));
+    SchServer.RobotManager.SendMessage(P.I_ObjectAddress, c_BroadCast, SCHM_EndModify, c_NoEventData);
+end;
+
+procedure SchPartTexts(Des: String; DX, DY, X, Y, Step: Integer);
+var
+    C  : ISch_Component;
+    It : ISch_Iterator;
+    P  : ISch_Parameter;
+    Row : Integer;
+begin
+    { Puts a part's visible texts where the drawing has room for them, upright: the designator at
+      DX, DY, then the comment and every other visible parameter one under the other from X, Y
+      down in steps of Step (all in mils, text base line, left aligned). }
+    if not Ok then Exit;
+    C := FindSchComp(Des);
+    if C = nil then begin Fail('no component ' + Des + ' on the sheet'); Exit; end;
+    PlaceText(C.Designator, DX, DY);
+    Row := 0;
+    if not C.Comment.IsHidden then begin PlaceText(C.Comment, X, Y); Row := 1; end;
+    It := C.SchIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eParameter));
+    P := It.FirstSchObject;
+    while P <> nil do
+    begin
+        if (not P.IsHidden) and (not SameText(P.Name, 'Comment')) then
+        begin
+            PlaceText(P, X, Y - Row * Step);
+            Row := Row + 1;
+        end;
+        P := It.NextSchObject;
+    end;
+    C.SchIterator_Destroy(It);
+    C.GraphicallyInvalidate;
+    Emit(F('designator', Des) + FI('rows', Row));
+end;
+
+function StdSheetMargin(Style: Integer): Integer;
+begin
+    { The border width of each standard sheet in mils (measured on Altium Designer 26.10). Like
+      SheetSizeX, SheetMarginWidth keeps the old style's value for the rest of the script. }
+    case Style of
+        eSheetA4, eSheetA3, eSheetA, eSheetB: Result := 200;
+        eSheetA2, eSheetA1, eSheetC, eSheetD: Result := 300;
+        eSheetA0, eSheetE: Result := 400;
+    else
+        Result := 0;
+    end;
+end;
+
+function StdSheetWidth(Style: Integer): Integer;
+begin
+    { Altium's standard sheet widths in mils (its own sizes, not ISO; measured on 26.10).
+      SheetSizeX keeps the previous style's width for the rest of a script that changes
+      SheetStyle (#38), so the title block is placed from this table instead; 0 = unknown style,
+      use what the sheet reports. }
+    case Style of
+        eSheetA4: Result := 11500;
+        eSheetA3: Result := 15500;
+        eSheetA2: Result := 22300;
+        eSheetA1: Result := 31500;
+        eSheetA0: Result := 44600;
+        eSheetA:  Result := 9500;
+        eSheetB:  Result := 15000;
+        eSheetC:  Result := 20000;
+        eSheetD:  Result := 32000;
+        eSheetE:  Result := 42000;
+    else
+        Result := 0;
+    end;
+end;
+
+procedure TitleField(Text: String; SheetX, Margin, X, Y: Integer);
+var
+    L : ISch_Label;
+begin
+    { One special string in Altium's standard title block, 3500 x 800 mil in the bottom-right
+      corner inside the sheet border; SheetX and Margin are the sheet width and border
+      (coordinates), X, Y are mils from the block's lower-left corner. }
+    L := SchServer.SchObjectFactory(eLabel, eCreate_Default);
+    L.Text := Text;
+    L.Location := Point(SheetX - Margin - MilsToCoord(3500 - X), Margin + MilsToCoord(Y));
+    CurSch.RegisterSchObjectInContainer(L);
+    SchServer.RobotManager.SendMessage(CurSch.I_ObjectAddress, c_BroadCast, SCHM_PrimitiveRegistration, L.I_ObjectAddress);
+end;
+
+procedure SheetParam(Name, Value: String);
+var
+    It : ISch_Iterator;
+    P  : ISch_Parameter;
+    Found : Boolean;
+begin
+    Found := False;
+    It := CurSch.SchIterator_Create;
+    It.SetState_IterationDepth(eIterateFirstLevel);
+    It.AddFilter_ObjectSet(MkSet(eParameter));
+    P := It.FirstSchObject;
+    while P <> nil do
+    begin
+        if SameText(P.Name, Name) then begin P.Text := Value; Found := True; end;
+        P := It.NextSchObject;
+    end;
+    CurSch.SchIterator_Destroy(It);
+    if not Found then
+    begin
+        P := SchServer.SchObjectFactory(eParameter, eCreate_Default);
+        P.Name := Name;
+        P.Text := Value;
+        P.IsHidden := True;
+        CurSch.AddSchObject(P);
+    end;
+end;
+
+procedure SchSheet(Style: Integer; Title, Revision, DocNumber, SheetNo, SheetTotal: String);
+var
+    It : ISch_Iterator;
+    O  : ISch_Label;
+    L  : TInterfaceList;
+    I  : Integer;
+    SheetX, Reported, Margin : Integer;
+begin
+    if not Ok then Exit;
+    { Without the modify notifications the new size shows on screen but is never saved, and
+      the compiler keeps checking objects against the old sheet boundary. }
+    SchServer.ProcessControl.PreProcess(CurSch, '');
+    SchServer.RobotManager.SendMessage(CurSch.I_ObjectAddress, c_BroadCast, SCHM_BeginModify, c_NoEventData);
+    CurSch.SheetStyle := Style;
+    CurSch.UseCustomSheet := False;
+    CurSch.TitleBlockOn := True;
+    SchServer.RobotManager.SendMessage(CurSch.I_ObjectAddress, c_BroadCast, SCHM_EndModify, c_NoEventData);
+    SchServer.ProcessControl.PostProcess(CurSch, '');
+    { A new sheet has none of these parameters, and the standard title block shows only its
+      labels: create the parameters and put their special strings into the block's fields. }
+    SheetParam('Title', Title);
+    SheetParam('Revision', Revision);
+    SheetParam('DocumentNumber', DocNumber);
+    SheetParam('SheetNumber', SheetNo);
+    SheetParam('SheetTotal', SheetTotal);
+    L := TInterfaceList.Create;
+    It := CurSch.SchIterator_Create;
+    It.SetState_IterationDepth(eIterateFirstLevel);
+    It.AddFilter_ObjectSet(MkSet(eLabel));
+    O := It.FirstSchObject;
+    while O <> nil do
+    begin
+        if (O.Text = '=Title') or (O.Text = '=Revision') or (O.Text = '=DocumentNumber')
+            or (O.Text = '=SheetNumber') or (O.Text = '=SheetTotal') then L.Add(O);
+        O := It.NextSchObject;
+    end;
+    CurSch.SchIterator_Destroy(It);
+    for I := 0 to L.Count - 1 do CurSch.RemoveSchObject(L.Items[I]);
+    Reported := CurSch.SheetSizeX;
+    SheetX := MilsToCoord(StdSheetWidth(Style));
+    if SheetX = 0 then SheetX := Reported;
+    Margin := MilsToCoord(StdSheetMargin(Style));
+    if Margin = 0 then Margin := CurSch.SheetMarginWidth;
+    TitleField('=Title', SheetX, Margin, 100, 560);
+    TitleField('=DocumentNumber', SheetX, Margin, 600, 270);
+    TitleField('=Revision', SheetX, Margin, 3000, 270);
+    TitleField('=SheetNumber', SheetX, Margin, 2262, 100);
+    TitleField('=SheetTotal', SheetX, Margin, 2410, 100);
+    CurSch.GraphicallyInvalidate;
+    Emit(F('title', Title) + FI('sheet_x_mils', CoordToMils(SheetX)) + FI('margin_mils', CoordToMils(Margin))
+        + FI('reported_x_mils', CoordToMils(Reported)) + FI('reported_margin_mils', CoordToMils(CurSch.SheetMarginWidth)));
+end;
+
+procedure SchAddSheetParam(Name, Value: String);
+var
+    P : ISch_Parameter;
+begin
+    if not Ok then Exit;
+    P := SchServer.SchObjectFactory(eParameter, eCreate_Default);
+    P.Name := Name;
+    P.Text := Value;
+    P.IsHidden := True;
+    CurSch.AddSchObject(P);
+end;
+
+procedure SchPlace(Lib, LibRef, Des: String; X, Y, Orient: Integer; Comment: String; Part: Integer);
+var
+    H      : Integer;
+    It     : ISch_Iterator;
+    C, New : ISch_Component;
+    Old    : TInterfaceList;
+    I      : Integer;
+begin
+    if not Ok then Exit;
+    if not FileExists(Lib) then begin Fail('symbol library not found: ' + Lib); Exit; end;
+    { Placing a part replaces that part of the designator only: the other parts of a
+      multi-part component stay where they are. }
+    Old := SchParts(Des, Part);
+    for I := 0 to Old.Count - 1 do
+    begin
+        CurSch.RemoveSchObject(Old.Items[I]);
+        Log('replaced existing ' + Des + ' part ' + IntToStr(Part));
+    end;
+    Old.Free;
+    H := 0;
+    CurSch.PlaceSchComponent(Lib, LibRef, H);
+    New := nil;
+    It := CurSch.SchIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eSchComponent));
+    C := It.FirstSchObject;
+    while C <> nil do
+    begin
+        if SameText(C.LibReference, LibRef) and (Pos('?', C.Designator.Text) > 0) then New := C;
+        C := It.NextSchObject;
+    end;
+    CurSch.SchIterator_Destroy(It);
+    if New = nil then begin Fail('Altium placed no ' + LibRef + ' from ' + Lib); Exit; end;
+    if Part > New.PartCount then
+    begin
+        CurSch.RemoveSchObject(New);
+        Fail(LibRef + ' has ' + IntToStr(New.PartCount) + ' parts; part ' + IntToStr(Part) + ' does not exist');
+        Exit;
+    end;
+    SchServer.RobotManager.SendMessage(New.I_ObjectAddress, c_BroadCast, SCHM_BeginModify, c_NoEventData);
+    New.CurrentPartID := Part;
+    New.Designator.Text := Des;
+    New.MoveToXY(MilsToCoord(X), MilsToCoord(Y));
+    New.Orientation := Orient;
+    if Comment <> '' then New.Comment.Text := Comment;
+    SchServer.RobotManager.SendMessage(New.I_ObjectAddress, c_BroadCast, SCHM_EndModify, c_NoEventData);
+    New.GraphicallyInvalidate;
+    Emit(F('designator', Des) + F('lib_ref', LibRef) + FI('part', Part) + FI('parts', New.PartCount));
+end;
+
+procedure CompParam(C: ISch_Component; Name, Value: String; Visible: Boolean);
+var
+    It : ISch_Iterator;
+    P  : ISch_Parameter;
+    Found : Boolean;
+begin
+    Found := False;
+    It := C.SchIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eParameter));
+    P := It.FirstSchObject;
+    while P <> nil do
+    begin
+        if SameText(P.Name, Name) then begin P.Text := Value; Found := True; end;
+        P := It.NextSchObject;
+    end;
+    C.SchIterator_Destroy(It);
+    if not Found then
+    begin
+        P := SchServer.SchObjectFactory(eParameter, eCreate_Default);
+        P.Name := Name;
+        P.Text := Value;
+        P.IsHidden := not Visible;
+        P.Location := C.Location;
+        C.AddSchObject(P);
+        SchServer.RobotManager.SendMessage(C.I_ObjectAddress, c_BroadCast, SCHM_PrimitiveRegistration, P.I_ObjectAddress);
+    end;
+end;
+
+procedure SchParam(Des, Name, Value: String; Visible: Boolean);
+var
+    L : TInterfaceList;
+    C : ISch_Component;
+    I : Integer;
+begin
+    { Every part of a multi-part component carries its own parameters: set them on all. }
+    if not Ok then Exit;
+    L := SchParts(Des, 0);
+    if L.Count = 0 then begin L.Free; Fail('no component ' + Des + ' on the sheet'); Exit; end;
+    for I := 0 to L.Count - 1 do
+    begin
+        C := L.Items[I];
+        CompParam(C, Name, Value, Visible);
+    end;
+    Emit(F('designator', Des) + F('parameter', Name) + FI('parts', L.Count));
+    L.Free;
+end;
+
+procedure SchParamRemove(Des, Name: String);
+var
+    C     : ISch_Component;
+    It    : ISch_Iterator;
+    P     : ISch_Parameter;
+    L     : TInterfaceList;
+    Parts : TInterfaceList;
+    I, K  : Integer;
+    N     : Integer;
+begin
+    if not Ok then Exit;
+    Parts := SchParts(Des, 0);
+    if Parts.Count = 0 then begin Parts.Free; Fail('no component ' + Des + ' on the sheet'); Exit; end;
+    N := 0;
+    for K := 0 to Parts.Count - 1 do
+    begin
+        C := Parts.Items[K];
+        L := TInterfaceList.Create;
+        It := C.SchIterator_Create;
+        It.AddFilter_ObjectSet(MkSet(eParameter));
+        P := It.FirstSchObject;
+        while P <> nil do
+        begin
+            if SameText(P.Name, Name) then L.Add(P);
+            P := It.NextSchObject;
+        end;
+        C.SchIterator_Destroy(It);
+        for I := 0 to L.Count - 1 do C.RemoveSchObject(L.Items[I]);
+        N := N + L.Count;
+        L.Free;
+        C.GraphicallyInvalidate;
+    end;
+    Parts.Free;
+    Emit(F('designator', Des) + F('parameter', Name) + FI('removed', N));
+end;
+
+procedure SchComponentKind(Des: String; NoBom: Boolean);
+var
+    C : ISch_Component;
+    L : TInterfaceList;
+    I : Integer;
+begin
+    { Standard, or Standard (No BOM) for parts that are PCB features (fiducials): they stay on
+      the board and in pick-and-place, but leave the BOM and ActiveBOM. Every part alike. }
+    if not Ok then Exit;
+    L := SchParts(Des, 0);
+    if L.Count = 0 then begin L.Free; Fail('no component ' + Des + ' on the sheet'); Exit; end;
+    for I := 0 to L.Count - 1 do
+    begin
+        C := L.Items[I];
+        SchServer.RobotManager.SendMessage(C.I_ObjectAddress, c_BroadCast, SCHM_BeginModify, c_NoEventData);
+        if NoBom then C.ComponentKind := eComponentKind_Standard_NoBOM
+        else C.ComponentKind := eComponentKind_Standard;
+        SchServer.RobotManager.SendMessage(C.I_ObjectAddress, c_BroadCast, SCHM_EndModify, c_NoEventData);
+    end;
+    L.Free;
+    Emit(F('designator', Des) + FB('no_bom', NoBom));
+end;
+
+procedure SchDelete(Des: String; Part: Integer);
+var
+    L : TInterfaceList;
+    I : Integer;
+begin
+    { Removes a component from the current sheet (it moves to another sheet with its UniqueID):
+      every part of it with Part 0, else that part only. }
+    if not Ok then Exit;
+    L := SchParts(Des, Part);
+    if L.Count = 0 then
+    begin
+        L.Free;
+        if Part = 0 then Fail('no component ' + Des + ' on the sheet')
+        else Fail('no part ' + IntToStr(Part) + ' of ' + Des + ' on the sheet');
+        Exit;
+    end;
+    for I := 0 to L.Count - 1 do CurSch.RemoveSchObject(L.Items[I]);
+    CurSch.GraphicallyInvalidate;
+    Emit(F('designator', Des) + FI('removed', L.Count));
+    L.Free;
+end;
+
+procedure SchUniqueId(Des, Uid: String);
+var
+    C : ISch_Component;
+begin
+    { A part placed anew on another sheet takes the UniqueID it had, so the board keeps its link:
+      in a flat project the link is the UniqueID alone. }
+    if not Ok then Exit;
+    C := FindSchComp(Des);
+    if C = nil then begin Fail('no component ' + Des + ' on the sheet'); Exit; end;
+    SchServer.RobotManager.SendMessage(C.I_ObjectAddress, c_BroadCast, SCHM_BeginModify, c_NoEventData);
+    C.UniqueId := Uid;
+    SchServer.RobotManager.SendMessage(C.I_ObjectAddress, c_BroadCast, SCHM_EndModify, c_NoEventData);
+    Emit(F('designator', Des) + F('unique_id', C.UniqueId));
+end;
+
+procedure RegObj(O: ISch_GraphicalObject);
+begin
+    CurSch.RegisterSchObjectInContainer(O);
+    SchServer.RobotManager.SendMessage(CurSch.I_ObjectAddress, c_BroadCast, SCHM_PrimitiveRegistration, O.I_ObjectAddress);
+end;
+
+procedure SchWire(Csv: String);
+var
+    W  : ISch_Wire;
+    SL : TStringList;
+    I, N : Integer;
+begin
+    if not Ok then Exit;
+    SL := IntList(Csv);
+    N := SL.Count div 2;
+    if N < 2 then begin Fail('a wire needs two points'); Exit; end;
+    W := SchServer.SchObjectFactory(eWire, eCreate_Default);
+    W.Location := Point(MilsToCoord(StrToInt(SL[0])), MilsToCoord(StrToInt(SL[1])));
+    for I := 1 to N do
+    begin
+        W.InsertVertex := I;
+        W.SetState_Vertex(I, Point(MilsToCoord(StrToInt(SL[2 * I - 2])), MilsToCoord(StrToInt(SL[2 * I - 1]))));
+    end;
+    RegObj(W);
+    SL.Free;
+end;
+
+procedure SchLabel(Text: String; X, Y, Orient: Integer);
+var
+    N : ISch_NetLabel;
+begin
+    if not Ok then Exit;
+    N := SchServer.SchObjectFactory(eNetLabel, eCreate_Default);
+    N.Text := Text;
+    N.Location := Point(MilsToCoord(X), MilsToCoord(Y));
+    N.Orientation := Orient;
+    RegObj(N);
+end;
+
+procedure SchPower(Text: String; X, Y, Style, Orient: Integer);
+var
+    P : ISch_PowerObject;
+begin
+    if not Ok then Exit;
+    P := SchServer.SchObjectFactory(ePowerObject, eCreate_Default);
+    P.Text := Text;
+    P.Location := Point(MilsToCoord(X), MilsToCoord(Y));
+    P.Style := Style;
+    P.Orientation := Orient;
+    P.ShowNetName := True;
+    RegObj(P);
+end;
+
+procedure SchNoErc(X, Y: Integer);
+var
+    N : ISch_NoERC;
+begin
+    if not Ok then Exit;
+    N := SchServer.SchObjectFactory(eNoERC, eCreate_Default);
+    N.Location := Point(MilsToCoord(X), MilsToCoord(Y));
+    RegObj(N);
+end;
+
+procedure SchJunction(X, Y: Integer);
+var
+    N : ISch_Junction;
+begin
+    if not Ok then Exit;
+    N := SchServer.SchObjectFactory(eJunction, eCreate_Default);
+    N.Location := Point(MilsToCoord(X), MilsToCoord(Y));
+    RegObj(N);
+end;
+
+procedure SchText(Text: String; X, Y, Orient: Integer);
+var
+    L : ISch_Label;
+begin
+    if not Ok then Exit;
+    L := SchServer.SchObjectFactory(eLabel, eCreate_Default);
+    L.Text := Text;
+    L.Location := Point(MilsToCoord(X), MilsToCoord(Y));
+    L.Orientation := Orient;
+    RegObj(L);
+end;
+
+procedure SchSheetSymBegin(Name, FileName: String; X, Y, W, H: Integer);
+var
+    It : ISch_Iterator;
+    O  : ISch_SheetSymbol;
+    L  : TInterfaceList;
+    I  : Integer;
+begin
+    { A sheet symbol: X, Y is its top-left corner, W x H its size. FileName names the child
+      sheet as the project lists it (relative to the project folder). A sheet symbol of the
+      same name on this sheet is replaced. }
+    if not Ok then Exit;
+    CurSheetSym := nil;
+    L := TInterfaceList.Create;
+    It := CurSch.SchIterator_Create;
+    It.SetState_IterationDepth(eIterateFirstLevel);
+    It.AddFilter_ObjectSet(MkSet(eSheetSymbol));
+    O := It.FirstSchObject;
+    while O <> nil do
+    begin
+        if SameText(O.SheetName.Text, Name) then L.Add(O);
+        O := It.NextSchObject;
+    end;
+    CurSch.SchIterator_Destroy(It);
+    for I := 0 to L.Count - 1 do CurSch.RemoveSchObject(L.Items[I]);
+    if L.Count > 0 then Log('replaced sheet symbol ' + Name);
+    L.Free;
+    CurSheetSym := SchServer.SchObjectFactory(eSheetSymbol, eCreate_Default);
+    if CurSheetSym = nil then begin Fail('Altium created no sheet symbol'); Exit; end;
+    CurSheetSym.Location := Point(MilsToCoord(X), MilsToCoord(Y));
+    CurSheetSym.XSize := MilsToCoord(W);
+    CurSheetSym.YSize := MilsToCoord(H);
+    CurSheetSym.SheetName.Text := Name;
+    CurSheetSym.SheetFileName.Text := FileName;
+    { Left at the factory defaults, neither text showed on the sheet. Place them as Altium's
+      own placement does: the name just above the top-left corner, the file name below the
+      bottom-left corner, and show both. }
+    CurSheetSym.SheetName.IsHidden := False;
+    CurSheetSym.SheetFileName.IsHidden := False;
+    CurSheetSym.SheetName.Location := Point(MilsToCoord(X), MilsToCoord(Y + 20));
+    CurSheetSym.SheetFileName.Location := Point(MilsToCoord(X), MilsToCoord(Y - H - 100));
+    CurSch.AddSchObject(CurSheetSym);
+    SchServer.RobotManager.SendMessage(CurSch.I_ObjectAddress, c_BroadCast, SCHM_PrimitiveRegistration,
+        CurSheetSym.I_ObjectAddress);
+    Emit(F('kind', 'sheet_symbol') + F('designator', Name) + F('file', FileName) + FI('x', X) + FI('y', Y)
+        + FI('width', W) + FI('height', H)
+        + FB('name_shown', not CurSheetSym.SheetName.IsHidden)
+        + FB('file_shown', not CurSheetSym.SheetFileName.IsHidden)
+        + FI('name_y', CoordToMils(CurSheetSym.SheetName.Location.Y))
+        + FI('file_y', CoordToMils(CurSheetSym.SheetFileName.Location.Y)));
+end;
+
+procedure SchSheetEntry(Name: String; Right: Boolean; Offset, IO: Integer);
+var
+    E    : ISch_SheetEntry;
+    X, Y : Integer;
+begin
+    { An entry on the left or right edge, Offset mils below the symbol's top. Its electrical
+      point is on that edge; a child sheet port of the same name connects to it. }
+    if not Ok then Exit;
+    if CurSheetSym = nil then begin Fail('sheet entry outside a sheet symbol'); Exit; end;
+    E := SchServer.SchObjectFactory(eSheetEntry, eCreate_Default);
+    if Right then E.Side := eRightSide else E.Side := eLeftSide;
+    E.DistanceFromTop := MilsToCoord(Offset);
+    E.Name := Name;
+    E.IOType := IO;
+    CurSheetSym.AddSchObject(E);
+    SchServer.RobotManager.SendMessage(CurSheetSym.I_ObjectAddress, c_BroadCast, SCHM_PrimitiveRegistration,
+        E.I_ObjectAddress);
+    X := CoordToMils(CurSheetSym.Location.X);
+    if Right then X := X + CoordToMils(CurSheetSym.XSize);
+    Y := CoordToMils(CurSheetSym.Location.Y) - Offset;
+    Emit(F('kind', 'sheet_entry') + F('entry', Name) + FI('x', X) + FI('y', Y));
+end;
+
+procedure SchSheetSymEnd;
+begin
+    if not Ok then Exit;
+    CurSheetSym.GraphicallyInvalidate;
+    CurSheetSym := nil;
+end;
+
+procedure SchPort(Name: String; X, Y, W, Style, IO: Integer);
+var
+    P : ISch_Port;
+begin
+    { A horizontal port from X, Y to X + W, Y; both ends are electrical. A port connects to the
+      sheet entry of the same name on the parent sheet's symbol for this sheet. }
+    if not Ok then Exit;
+    P := SchServer.SchObjectFactory(ePort, eCreate_Default);
+    if P = nil then begin Fail('Altium created no port'); Exit; end;
+    P.Location := Point(MilsToCoord(X), MilsToCoord(Y));
+    P.Width := MilsToCoord(W);
+    P.Name := Name;
+    P.Style := Style;
+    P.IOType := IO;
+    CurSch.AddSchObject(P);
+    SchServer.RobotManager.SendMessage(CurSch.I_ObjectAddress, c_BroadCast, SCHM_PrimitiveRegistration, P.I_ObjectAddress);
+    Emit(F('port', Name) + FI('x', X) + FI('y', Y) + FI('x2', X + W) + FI('y2', Y));
+end;
+
+procedure SchSave;
+begin
+    if not Ok then Exit;
+    CurSch.GraphicallyInvalidate;
+    CurSchDoc.SetModified(True);
+    Emit(FB('saved', CurSchDoc.DoFileSave('')));
+end;
+
+procedure PartPins(C: ISch_Component; Des: String);
+var
+    It : ISch_Iterator;
+    P  : ISch_Pin;
+    X, Y, L : Integer;
+begin
+    It := C.SchIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(ePin));
+    P := It.FirstSchObject;
+    while P <> nil do
+    begin
+        if (P.OwnerPartId = C.CurrentPartID) or (P.OwnerPartId = 0) then
+        begin
+            X := CoordToMils(P.Location.X);
+            Y := CoordToMils(P.Location.Y);
+            L := CoordToMils(P.PinLength);
+            if P.Orientation = eRotate0 then X := X + L
+            else if P.Orientation = eRotate90 then Y := Y + L
+            else if P.Orientation = eRotate180 then X := X - L
+            else Y := Y - L;
+            Emit(F('designator', Des) + FI('part', C.CurrentPartID) + F('pin', P.Designator) + F('pin_name', P.Name)
+                + FI('x', X) + FI('y', Y) + FI('orientation', P.Orientation));
+        end;
+        P := It.NextSchObject;
+    end;
+    C.SchIterator_Destroy(It);
+end;
+
+procedure SchPins(Des: String; Part: Integer);
+var
+    L : TInterfaceList;
+    C : ISch_Component;
+    I : Integer;
+begin
+    { The active pins of each placed part (Part 0: every part on the sheet). }
+    if not Ok then Exit;
+    L := SchParts(Des, Part);
+    if L.Count = 0 then
+    begin
+        L.Free;
+        if Part = 0 then Fail('no component ' + Des + ' on the sheet')
+        else Fail('no part ' + IntToStr(Part) + ' of ' + Des + ' on the sheet');
+        Exit;
+    end;
+    for I := 0 to L.Count - 1 do
+    begin
+        C := L.Items[I];
+        PartPins(C, Des);
+    end;
+    L.Free;
+end;
+
+procedure SchComponents;
+var
+    It : ISch_Iterator;
+    C  : ISch_Component;
+begin
+    if not Ok then Exit;
+    It := CurSch.SchIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eSchComponent));
+    C := It.FirstSchObject;
+    while C <> nil do
+    begin
+        Emit(F('designator', C.Designator.Text) + F('lib_ref', C.LibReference) + F('comment', C.Comment.Text)
+            + FI('x', CoordToMils(C.Location.X)) + FI('y', CoordToMils(C.Location.Y)) + FI('orientation', C.Orientation)
+            + F('unique_id', C.UniqueId) + FI('part', C.CurrentPartID) + FI('parts', C.PartCount));
+        C := It.NextSchObject;
+    end;
+    CurSch.SchIterator_Destroy(It);
+end;
+
+{ ---------------------------------------------------------------------- PCB --- }
+
+procedure PcbOpen(Path: String);
+begin
+    if not Ok then Exit;
+    CurBoardDoc := ShowDoc('PCB', Path);
+    if CurBoardDoc = nil then begin Fail('cannot open board ' + Path); Exit; end;
+    CurBoard := PCBServer.GetPCBBoardByPath(Path);
+    if CurBoard = nil then begin Fail('not a board: ' + Path); Exit; end;
+    if not SameText(CurBoard.FileName, Path) then begin Fail('Altium returned another board: ' + CurBoard.FileName); Exit; end;
+    Emit(F('board', Path) + FI('x_origin', CurBoard.XOrigin) + FI('y_origin', CurBoard.YOrigin));
+end;
+
+procedure PcbOrigin(X, Y: Integer);
+begin
+    { X, Y are absolute: every other PCB coordinate is relative to this origin, and Altium's
+      workspace has no negative absolute coordinates. }
+    if not Ok then Exit;
+    if (X < 0) or (Y < 0) then begin Fail('the origin must have non-negative absolute coordinates'); Exit; end;
+    CurBoard.XOrigin := X;
+    CurBoard.YOrigin := Y;
+    CurBoard.ViewManager_FullUpdate;
+    Emit(FI('x_origin', CurBoard.XOrigin) + FI('y_origin', CurBoard.YOrigin));
+end;
+
+procedure SetBoardRegion(O: IPCB_BoardOutline);
+var
+    It : IPCB_BoardIterator;
+    R  : IPCB_Region;
+    L  : TInterfaceList;
+    GP : IPCB_GeometricPolygon;
+    C  : IPCB_Contour;
+    Seg : TPolySegment;
+    I  : Integer;
+begin
+    { Altium keeps the layer stack in a board region (kind 3) that is drawn separately from the
+      outline; a new board's region is the default 6 x 4 inch board. Left alone, the part of the
+      new outline outside it has no stack: 3D shows it without mask, and ODB++ without layers.
+      A board with exactly one region gets the outline as its region. }
+    L := TInterfaceList.Create;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eRegionObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    R := It.FirstPCBObject;
+    while R <> nil do
+    begin
+        if (R.Kind = 3) and not R.InComponent then L.Add(R);
+        R := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+    if L.Count = 1 then
+    begin
+        R := L.Items[0];
+        GP := PCBServer.PCBGeometricPolygonFactory;
+        C := GP.AddEmptyContour;
+        for I := 0 to O.PointCount - 1 do
+        begin
+            Seg := O.Segments[I];        { a record: read it into a variable, never field by index }
+            C.AddPoint(Seg.vx, Seg.vy);
+        end;
+        PCBServer.SendMessageToRobots(R.I_ObjectAddress, c_Broadcast, PCBM_BeginModify, c_NoEventData);
+        R.SetOutlineContour(C);
+        PCBServer.SendMessageToRobots(R.I_ObjectAddress, c_Broadcast, PCBM_EndModify, c_NoEventData);
+    end;
+    Emit(FI('board_regions', L.Count) + FB('region_set', L.Count = 1));
+    L.Free;
+end;
+
+procedure PcbOutline(Csv: String);
+var
+    O   : IPCB_BoardOutline;
+    Seg : TPolySegment;
+    SL  : TStringList;
+    I, N : Integer;
+begin
+    if not Ok then Exit;
+    SL := IntList(Csv);
+    N := SL.Count div 2;
+    if N < 3 then begin Fail('an outline needs three points'); Exit; end;
+    O := CurBoard.BoardOutline;
+    PCBServer.PreProcess;
+    O.BeginModify;
+    O.PointCount := N;
+    for I := 0 to N - 1 do
+    begin
+        Seg := TPolySegment;
+        Seg.Kind := ePolySegmentLine;
+        Seg.vx := CurBoard.XOrigin + StrToInt(SL[2 * I]);
+        Seg.vy := CurBoard.YOrigin + StrToInt(SL[2 * I + 1]);
+        O.Segments[I] := Seg;
+    end;
+    O.EndModify;
+    O.Invalidate;
+    O.Rebuild;
+    O.Validate;
+    SetBoardRegion(O);
+    PCBServer.PostProcess;
+    CurBoard.ViewManager_FullUpdate;
+    Emit(FI('points', O.PointCount)
+        + FI('width', O.BoundingRectangle.Right - O.BoundingRectangle.Left)
+        + FI('height', O.BoundingRectangle.Top - O.BoundingRectangle.Bottom));
+    SL.Free;
+end;
+
+function FindPcbComp(Des: String): IPCB_Component;
+var
+    It : IPCB_BoardIterator;
+    C  : IPCB_Component;
+begin
+    Result := nil;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eComponentObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    C := It.FirstPCBObject;
+    while C <> nil do
+    begin
+        if SameText(C.Name.Text, Des) then Result := C;
+        C := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+end;
+
+function FindNet(Name: String): IPCB_Net;
+var
+    It : IPCB_BoardIterator;
+    N  : IPCB_Net;
+begin
+    Result := nil;
+    if Name = '' then Exit;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eNetObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    N := It.FirstPCBObject;
+    while N <> nil do
+    begin
+        if SameText(N.Name, Name) then Result := N;
+        N := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+end;
+
+procedure PcbPlace(Des: String; X, Y, Rot: Integer; Bottom: Boolean);
+var
+    C : IPCB_Component;
+begin
+    if not Ok then Exit;
+    C := FindPcbComp(Des);
+    if C = nil then begin Fail('no component ' + Des + ' on the board (run Update PCB first)'); Exit; end;
+    PCBServer.PreProcess;
+    PCBServer.SendMessageToRobots(C.I_ObjectAddress, c_Broadcast, PCBM_BeginModify, c_NoEventData);
+    if Bottom and (C.Layer <> eBottomLayer) then C.Layer := eBottomLayer;
+    if (not Bottom) and (C.Layer <> eTopLayer) then C.Layer := eTopLayer;
+    C.Rotation := Rot;
+    C.MoveToXY(CurBoard.XOrigin + X, CurBoard.YOrigin + Y);
+    PCBServer.SendMessageToRobots(C.I_ObjectAddress, c_Broadcast, PCBM_EndModify, c_NoEventData);
+    PCBServer.PostProcess;
+    Emit(F('designator', Des) + FI('x', C.X - CurBoard.XOrigin) + FI('y', C.Y - CurBoard.YOrigin)
+        + FB('bottom', C.Layer = eBottomLayer));
+end;
+
+procedure PcbTrack(Net: String; Layer, X1, Y1, X2, Y2, W: Integer; Locked: Boolean);
+var
+    T : IPCB_Track;
+    N : IPCB_Net;
+begin
+    if not Ok then Exit;
+    N := FindNet(Net);
+    if (Net <> '') and (N = nil) then begin Fail('no net ' + Net + ' on the board'); Exit; end;
+    PCBServer.PreProcess;
+    T := PCBServer.PCBObjectFactory(eTrackObject, eNoDimension, eCreate_Default);
+    T.x1 := CurBoard.XOrigin + X1; T.y1 := CurBoard.YOrigin + Y1;
+    T.x2 := CurBoard.XOrigin + X2; T.y2 := CurBoard.YOrigin + Y2;
+    T.Layer := Layer;
+    T.Width := W;
+    if N <> nil then T.Net := N;
+    { Locked primitives are left alone by the autorouter and by interactive rip-up. }
+    T.Moveable := not Locked;
+    CurBoard.AddPCBObject(T);
+    PCBServer.SendMessageToRobots(CurBoard.I_ObjectAddress, c_Broadcast, PCBM_BoardRegisteration, T.I_ObjectAddress);
+    PCBServer.PostProcess;
+end;
+
+procedure PcbArc(Net: String; Layer, XC, YC, R, A1, A2, W: Integer);
+var
+    A : IPCB_Arc;
+    N : IPCB_Net;
+begin
+    if not Ok then Exit;
+    N := FindNet(Net);
+    if (Net <> '') and (N = nil) then begin Fail('no net ' + Net + ' on the board'); Exit; end;
+    PCBServer.PreProcess;
+    A := PCBServer.PCBObjectFactory(eArcObject, eNoDimension, eCreate_Default);
+    A.XCenter := CurBoard.XOrigin + XC; A.YCenter := CurBoard.YOrigin + YC; A.Radius := R;
+    A.StartAngle := A1; A.EndAngle := A2;
+    A.Layer := Layer;
+    A.LineWidth := W;
+    if N <> nil then A.Net := N;
+    CurBoard.AddPCBObject(A);
+    PCBServer.SendMessageToRobots(CurBoard.I_ObjectAddress, c_Broadcast, PCBM_BoardRegisteration, A.I_ObjectAddress);
+    PCBServer.PostProcess;
+end;
+
+procedure PcbVia(Net: String; X, Y, Hole, Size: Integer; Locked: Boolean);
+var
+    V : IPCB_Via;
+    N : IPCB_Net;
+begin
+    if not Ok then Exit;
+    N := FindNet(Net);
+    if (Net <> '') and (N = nil) then begin Fail('no net ' + Net + ' on the board'); Exit; end;
+    PCBServer.PreProcess;
+    V := PCBServer.PCBObjectFactory(eViaObject, eNoDimension, eCreate_Default);
+    V.x := CurBoard.XOrigin + X;
+    V.y := CurBoard.YOrigin + Y;
+    V.HoleSize := Hole;
+    V.Size := Size;
+    V.LowLayer := eTopLayer;
+    V.HighLayer := eBottomLayer;
+    if N <> nil then V.Net := N;
+    V.Moveable := not Locked;
+    CurBoard.AddPCBObject(V);
+    PCBServer.SendMessageToRobots(CurBoard.I_ObjectAddress, c_Broadcast, PCBM_BoardRegisteration, V.I_ObjectAddress);
+    PCBServer.PostProcess;
+end;
+
+function DropPolygon(Name: String): Integer;
+var
+    It : IPCB_BoardIterator;
+    P  : IPCB_Polygon;
+    L  : TInterfaceList;
+    I  : Integer;
+begin
+    { A named polygon is replaced, never duplicated, so a layout script can be re-run. }
+    L := TInterfaceList.Create;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(ePolyObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    P := It.FirstPCBObject;
+    while P <> nil do
+    begin
+        if SameText(P.Name, Name) then L.Add(P);
+        P := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+    PCBServer.PreProcess;
+    for I := 0 to L.Count - 1 do CurBoard.RemovePCBObject(L.Items[I]);
+    PCBServer.PostProcess;
+    Result := L.Count;
+    L.Free;
+end;
+
+procedure PcbDeletePolygon(Name: String);
+begin
+    { Remove a named polygon, e.g. an inner ground area the autorouter should not repour around
+      on every move; pcb_polygon puts it back afterwards. }
+    if not Ok then Exit;
+    Emit(F('polygon', Name) + FI('removed', DropPolygon(Name)));
+end;
+
+procedure PcbPolygon(Net: String; Layer: Integer; Csv, Name: String; Clearance: Integer);
+var
+    P   : IPCB_Polygon;
+    N   : IPCB_Net;
+    Seg : TPolySegment;
+    SL  : TStringList;
+    I, K : Integer;
+begin
+    if not Ok then Exit;
+    N := FindNet(Net);
+    if (Net <> '') and (N = nil) then begin Fail('no net ' + Net + ' on the board'); Exit; end;
+    if Name <> '' then DropPolygon(Name);
+    SL := IntList(Csv);
+    K := SL.Count div 2;
+    PCBServer.PreProcess;
+    P := PCBServer.PCBObjectFactory(ePolyObject, eNoDimension, eCreate_Default);
+    P.Layer := Layer;
+    P.PolyHatchStyle := ePolySolid;
+    P.RemoveDead := True;
+    P.PourOver := ePolygonPourOver_SameNet;
+    P.Name := Name;
+    if N <> nil then P.Net := N;
+    P.PointCount := K;
+    for I := 0 to K - 1 do
+    begin
+        Seg := TPolySegment;
+        Seg.Kind := ePolySegmentLine;
+        Seg.vx := CurBoard.XOrigin + StrToInt(SL[2 * I]);
+        Seg.vy := CurBoard.YOrigin + StrToInt(SL[2 * I + 1]);
+        P.Segments[I] := Seg;
+    end;
+    CurBoard.AddPCBObject(P);
+    P.Rebuild;
+    PCBServer.SendMessageToRobots(CurBoard.I_ObjectAddress, c_Broadcast, PCBM_BoardRegisteration, P.I_ObjectAddress);
+    PCBServer.PostProcess;
+    SL.Free;
+end;
+
+procedure PcbRegion(Net: String; Layer: Integer; Csv: String);
+var
+    R    : IPCB_Region;
+    N    : IPCB_Net;
+    GP   : IPCB_GeometricPolygon;
+    C    : IPCB_Contour;
+    SL   : TStringList;
+    I, K : Integer;
+begin
+    { A filled region with a straight-edged outline: silkscreen artwork (a logo) on an overlay
+      layer, or a copper area on a signal layer (with a net). }
+    if not Ok then Exit;
+    N := nil;
+    if Net <> '' then
+    begin
+        N := FindNet(Net);
+        if N = nil then begin Fail('no net ' + Net + ' on the board'); Exit; end;
+    end;
+    SL := IntList(Csv);
+    K := SL.Count div 2;
+    GP := PCBServer.PCBGeometricPolygonFactory;
+    C := GP.AddEmptyContour;
+    for I := 0 to K - 1 do
+        C.AddPoint(CurBoard.XOrigin + StrToInt(SL[2 * I]), CurBoard.YOrigin + StrToInt(SL[2 * I + 1]));
+    PCBServer.PreProcess;
+    R := PCBServer.PCBObjectFactory(eRegionObject, eNoDimension, eCreate_Default);
+    R.Layer := Layer;
+    R.SetOutlineContour(C);
+    if N <> nil then R.Net := N;
+    CurBoard.AddPCBObject(R);
+    PCBServer.SendMessageToRobots(CurBoard.I_ObjectAddress, c_Broadcast, PCBM_BoardRegisteration, R.I_ObjectAddress);
+    PCBServer.PostProcess;
+    SL.Free;
+    Emit(FI('layer', Layer) + FI('points', K));
+end;
+
+procedure PcbText(Layer, X, Y, Height, Rot: Integer; Text: String; Mirror: Boolean);
+var
+    T : IPCB_Text;
+begin
+    if not Ok then Exit;
+    PCBServer.PreProcess;
+    T := PCBServer.PCBObjectFactory(eTextObject, eNoDimension, eCreate_Default);
+    T.XLocation := CurBoard.XOrigin + X;
+    T.YLocation := CurBoard.YOrigin + Y;
+    T.Layer := Layer;
+    T.Text := Text;
+    T.Size := Height;
+    T.Width := Height div 8;
+    T.Rotation := Rot;
+    T.MirrorFlag := Mirror;
+    CurBoard.AddPCBObject(T);
+    PCBServer.SendMessageToRobots(CurBoard.I_ObjectAddress, c_Broadcast, PCBM_BoardRegisteration, T.I_ObjectAddress);
+    PCBServer.PostProcess;
+end;
+
+procedure PcbTextReplace(Old, New: String);
+var
+    It : IPCB_BoardIterator;
+    T  : IPCB_Text;
+    N  : IPCB_Text;
+    L  : TInterfaceList;
+    I  : Integer;
+begin
+    { Free strings whose whole text is Old get New, in place (layer, position and size stay), e.g.
+      a revision mark. Finding none is an error, so a stale Old never passes silently. }
+    if not Ok then Exit;
+    L := TInterfaceList.Create;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eTextObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    T := It.FirstPCBObject;
+    while T <> nil do
+    begin
+        { Component-owned texts are left alone: their replica would be added as free text and no
+          longer move with the part. }
+        if (not T.IsDesignator) and (not T.IsComment) and (not T.InComponent) and (T.Text = Old) then L.Add(T);
+        T := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+    if L.Count = 0 then begin L.Free; Fail('no free text "' + Old + '" on the board'); Exit; end;
+    { A replica replaces each text: Altium computes the extent only when a text is added (see
+      PcbTextSet), and a longer text must not keep the shorter one's box. }
+    PCBServer.PreProcess;
+    for I := 0 to L.Count - 1 do
+    begin
+        T := L.Items[I];
+        N := T.Replicate;
+        N.Text := New;
+        CurBoard.AddPCBObject(N);
+        PCBServer.SendMessageToRobots(CurBoard.I_ObjectAddress, c_Broadcast, PCBM_BoardRegisteration, N.I_ObjectAddress);
+        CurBoard.RemovePCBObject(T);
+    end;
+    PCBServer.PostProcess;
+    Emit(F('old', Old) + F('new', New) + FI('replaced', L.Count));
+    L.Free;
+end;
+
+{ Rules: a rule added to the board takes priority 1 (the highest) and pushes the others down,
+  and Altium refuses a scripted Priority change. Add general rules before specific ones. }
+function DropRule(Name: String): Boolean;
+var
+    It : IPCB_BoardIterator;
+    R  : IPCB_Rule;
+    L  : TInterfaceList;
+    I  : Integer;
+begin
+    { Rule ops are idempotent: a rule of the same name is replaced, never duplicated. }
+    L := TInterfaceList.Create;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eRuleObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    R := It.FirstPCBObject;
+    while R <> nil do
+    begin
+        if SameText(R.Name, Name) then L.Add(R);
+        R := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+    for I := 0 to L.Count - 1 do CurBoard.RemovePCBObject(L.Items[I]);
+    Result := L.Count > 0;
+    L.Free;
+end;
+
+procedure PcbRuleClearance(Name, Scope1, Scope2: String; Gap: Integer);
+var
+    R : IPCB_ClearanceConstraint;
+begin
+    if not Ok then Exit;
+    DropRule(Name);
+    R := PCBServer.PCBRuleFactory(eRule_Clearance);
+    R.Name := Name;
+    R.Scope1Expression := Scope1;
+    R.Scope2Expression := Scope2;
+    R.Gap := Gap;
+    CurBoard.AddPCBObject(R);
+    Emit(F('rule', Name));
+end;
+
+procedure PcbRuleWidth(Name, Scope: String; MinW, PrefW, MaxW: Integer);
+var
+    R : IPCB_MaxMinWidthConstraint;
+    L : Integer;
+begin
+    if not Ok then Exit;
+    DropRule(Name);
+    R := PCBServer.PCBRuleFactory(eRule_MaxMinWidth);
+    R.Name := Name;
+    R.Scope1Expression := Scope;
+    for L := eTopLayer to eBottomLayer do
+    begin
+        R.MinWidth[L] := MinW;
+        R.MaxWidth[L] := MaxW;
+        R.FavoredWidth[L] := PrefW;
+    end;
+    CurBoard.AddPCBObject(R);
+    Emit(F('rule', Name));
+end;
+
+procedure PcbNetClass(Name, Csv: String);
+var
+    NC : IPCB_ObjectClass;
+    SL : TStringList;
+    I  : Integer;
+begin
+    if not Ok then Exit;
+    SL := TStringList.Create;
+    SL.Delimiter := ',';
+    SL.StrictDelimiter := True;
+    SL.DelimitedText := Csv;
+    NC := PCBServer.PCBClassFactoryByClassMember(eClassMemberKind_Net);
+    NC.SuperClass := False;
+    NC.Name := Name;
+    for I := 0 to SL.Count - 1 do NC.AddMemberByName(SL[I]);
+    CurBoard.AddPCBObject(NC);
+    Emit(F('class', Name) + FI('members', SL.Count));
+    SL.Free;
+end;
+
+function PolygonPieces(P: IPCB_Polygon): Integer;
+var
+    GI : IPCB_GroupIterator;
+    O  : IPCB_Primitive;
+begin
+    { What a pour produced: its regions, tracks and arcs. An unpoured or shelved polygon has none. }
+    Result := 0;
+    GI := P.GroupIterator_Create;
+    GI.AddFilter_ObjectSet(MkSet(eRegionObject, eTrackObject, eArcObject));
+    O := GI.FirstPCBObject;
+    while O <> nil do
+    begin
+        Result := Result + 1;
+        O := GI.NextPCBObject;
+    end;
+    P.GroupIterator_Destroy(GI);
+end;
+
+function NetName(O: IPCB_Primitive): String;
+begin
+    Result := '';
+    if O.Net <> nil then Result := O.Net.Name;
+end;
+
+procedure PcbRepour;
+var
+    It : IPCB_BoardIterator;
+    P  : IPCB_Polygon;
+    L  : TInterfaceList;
+    I, Empty : Integer;
+begin
+    { Repour the polygons of this board (CurBoard), each through its own Rebuild. The process
+      route (PCB:ChangeObject Action=RepourAllPolygons) acts on the focused view, so it repoured
+      another open board, and after a project reopen it silently did nothing. Collect first:
+      changing a primitive re-registers it with a running iterator. }
+    if not Ok then Exit;
+    L := TInterfaceList.Create;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(ePolyObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    P := It.FirstPCBObject;
+    while P <> nil do
+    begin
+        L.Add(P);
+        P := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+    PCBServer.PreProcess;
+    for I := 0 to L.Count - 1 do
+    begin
+        P := L.Items[I];
+        P.Rebuild;
+    end;
+    PCBServer.PostProcess;
+    ResetParameters;
+    AddStringParameter('Action', 'RebuildConnectivity');
+    RunProcess('PCB:UpdateConnectivity');
+    CurBoard.ViewManager_FullUpdate;
+    Empty := 0;
+    for I := 0 to L.Count - 1 do
+    begin
+        P := L.Items[I];
+        if PolygonPieces(P) = 0 then Empty := Empty + 1;
+        Emit(F('polygon', P.Name) + F('net', NetName(P)) + FI('layer', P.Layer) + FI('pieces', PolygonPieces(P)));
+    end;
+    Emit(F('kind', 'summary') + FI('polygons', L.Count) + FI('empty', Empty));
+    L.Free;
+end;
+
+procedure PcbPolygons;
+var
+    It : IPCB_BoardIterator;
+    P  : IPCB_Polygon;
+    R  : TCoordRect;
+begin
+    if not Ok then Exit;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(ePolyObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    P := It.FirstPCBObject;
+    while P <> nil do
+    begin
+        R := P.BoundingRectangle;
+        Emit(F('polygon', P.Name) + F('net', NetName(P)) + FI('layer', P.Layer) + F('layer_label', Layer2String(P.Layer))
+            + FI('pieces', PolygonPieces(P)) + FB('locked', not P.Moveable)
+            + FI('box_left', R.Left - CurBoard.XOrigin) + FI('box_bottom', R.Bottom - CurBoard.YOrigin)
+            + FI('box_right', R.Right - CurBoard.XOrigin) + FI('box_top', R.Top - CurBoard.YOrigin));
+        P := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+end;
+
+function LayerWanted(Layer: Integer; Bars: String): Boolean;
+begin
+    Result := (Bars = '') or (Pos('|' + IntToStr(Layer) + '|', Bars) > 0);
+end;
+
+function TextHidden(T: IPCB_Text): Boolean;
+begin
+    { A component's designator and comment are texts that print only when the component shows
+      them (NameOn, CommentOn); a free text always prints. }
+    Result := False;
+    if T.InComponent and (T.Component <> nil) then
+    begin
+        if T.IsDesignator then Result := not T.Component.NameOn
+        else if T.IsComment then Result := not T.Component.CommentOn;
+    end;
+end;
+
+function PrimitiveFields(Kind: String; O: IPCB_Primitive): String;
+var
+    R  : TCoordRect;
+    XO, YO : Integer;
+begin
+    XO := CurBoard.XOrigin;
+    YO := CurBoard.YOrigin;
+    R := O.BoundingRectangle;
+    Result := F('kind', Kind) + FI('layer', O.Layer) + F('layer_label', Layer2String(O.Layer)) + F('net', NetName(O))
+        + FB('locked', not O.Moveable) + FB('in_component', O.InComponent) + FB('in_polygon', O.InPolygon)
+        + FI('box_left', R.Left - XO) + FI('box_bottom', R.Bottom - YO)
+        + FI('box_right', R.Right - XO) + FI('box_top', R.Top - YO);
+    if Kind = 'track' then
+        Result := Result + FI('x1', O.x1 - XO) + FI('y1', O.y1 - YO) + FI('x2', O.x2 - XO) + FI('y2', O.y2 - YO)
+            + FI('width', O.Width)
+    else if Kind = 'arc' then
+        Result := Result + FI('xc', O.XCenter - XO) + FI('yc', O.YCenter - YO) + FI('r', O.Radius)
+            + FI('start', Round(O.StartAngle)) + FI('end', Round(O.EndAngle)) + FI('width', O.LineWidth)
+    else if Kind = 'via' then
+        Result := Result + FI('x', O.x - XO) + FI('y', O.y - YO) + FI('hole', O.HoleSize) + FI('diameter', O.Size)
+            + FI('low_layer', O.LowLayer) + FI('high_layer', O.HighLayer)
+    else if Kind = 'fill' then
+        Result := Result + FI('x1', O.X1Location - XO) + FI('y1', O.Y1Location - YO)
+            + FI('x2', O.X2Location - XO) + FI('y2', O.Y2Location - YO) + FI('rotation', Round(O.Rotation))
+    else if Kind = 'region' then
+        Result := Result + FI('region_kind', O.Kind)
+    else if Kind = 'text' then
+        Result := Result + F('text', O.Text) + FI('x', O.XLocation - XO) + FI('y', O.YLocation - YO)
+            + FI('height', O.Size) + FI('stroke', O.Width) + FI('rotation', Round(O.Rotation))
+            + FB('mirror', O.MirrorFlag) + FB('designator', O.IsDesignator) + FB('comment', O.IsComment)
+            + FB('hidden', TextHidden(O));
+end;
+
+procedure PcbPrimitives(Kinds, Bars: String; Offset, Limit: Integer);
+var
+    It    : IPCB_BoardIterator;
+    O     : IPCB_Primitive;
+    KL    : TStringList;
+    K, N, Shown : Integer;
+    Kind  : String;
+begin
+    { Read the board's primitives: Kinds is a comma list (track, arc, via, fill, region, text);
+      Bars a |layer|layer| filter ('' for every layer). Paged with Offset and Limit; the summary
+      item says how many matched in total, so a caller can tell a short list from a cut one. }
+    if not Ok then Exit;
+    KL := IntList(Kinds);
+    N := 0;
+    Shown := 0;
+    for K := 0 to KL.Count - 1 do
+    begin
+        Kind := KL[K];
+        It := CurBoard.BoardIterator_Create;
+        if Kind = 'track' then It.AddFilter_ObjectSet(MkSet(eTrackObject))
+        else if Kind = 'arc' then It.AddFilter_ObjectSet(MkSet(eArcObject))
+        else if Kind = 'via' then It.AddFilter_ObjectSet(MkSet(eViaObject))
+        else if Kind = 'fill' then It.AddFilter_ObjectSet(MkSet(eFillObject))
+        else if Kind = 'region' then It.AddFilter_ObjectSet(MkSet(eRegionObject))
+        else It.AddFilter_ObjectSet(MkSet(eTextObject));
+        It.AddFilter_LayerSet(AllLayers);
+        It.AddFilter_Method(eProcessAll);
+        O := It.FirstPCBObject;
+        while O <> nil do
+        begin
+            if LayerWanted(O.Layer, Bars) then
+            begin
+                if (N >= Offset) and (Shown < Limit) then
+                begin
+                    Emit(PrimitiveFields(Kind, O));
+                    Shown := Shown + 1;
+                end;
+                N := N + 1;
+            end;
+            O := It.NextPCBObject;
+        end;
+        CurBoard.BoardIterator_Destroy(It);
+    end;
+    KL.Free;
+    Emit(F('kind', 'summary') + FI('total', N) + FI('shown', Shown) + FI('offset', Offset));
+end;
+
+procedure PcbTextSet(Match: String; Layer: Integer; Fields: String; X, Y, Height, Rot: Integer;
+    Mirror: Boolean; NewText: String);
+var
+    It : IPCB_BoardIterator;
+    T  : IPCB_Text;
+    N  : IPCB_Text;
+    L  : TInterfaceList;
+    Before : String;
+begin
+    { Change one free text found by its whole text (and layer, unless Layer is -1). Fields says
+      what to set: p = position, h = height, r = rotation, m = mirror, t = text. Exactly one
+      text must match: none or several is an error, never a guess. }
+    if not Ok then Exit;
+    L := TInterfaceList.Create;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eTextObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    T := It.FirstPCBObject;
+    while T <> nil do
+    begin
+        if (not T.IsDesignator) and (not T.IsComment) and (not T.InComponent) and (T.Text = Match)
+            and ((Layer < 0) or (T.Layer = Layer)) then L.Add(T);
+        T := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+    if L.Count <> 1 then
+    begin
+        Fail(IntToStr(L.Count) + ' free texts match "' + Match + '"; exactly one must');
+        L.Free;
+        Exit;
+    end;
+    T := L.Items[0];
+    L.Free;
+    Before := FI('x_before', T.XLocation - CurBoard.XOrigin) + FI('y_before', T.YLocation - CurBoard.YOrigin)
+        + FI('height_before', T.Size);
+    { Altium computes a text's bounding rectangle when the text is added to a board; changing a
+      text in place leaves the old extent (measured: a text grown to 1.0 mm kept its 0.8 mm box
+      through redraws and a full update), so a silkscreen check would read the old size. The
+      change goes to a replica that replaces the original. }
+    PCBServer.PreProcess;
+    N := T.Replicate;
+    if Pos('p', Fields) > 0 then
+    begin
+        N.XLocation := CurBoard.XOrigin + X;
+        N.YLocation := CurBoard.YOrigin + Y;
+    end;
+    if Pos('h', Fields) > 0 then
+    begin
+        N.Size := Height;
+        N.Width := Height div 8;
+    end;
+    if Pos('r', Fields) > 0 then N.Rotation := Rot;
+    if Pos('m', Fields) > 0 then N.MirrorFlag := Mirror;
+    if Pos('t', Fields) > 0 then N.Text := NewText;
+    CurBoard.AddPCBObject(N);
+    PCBServer.SendMessageToRobots(CurBoard.I_ObjectAddress, c_Broadcast, PCBM_BoardRegisteration, N.I_ObjectAddress);
+    CurBoard.RemovePCBObject(T);
+    PCBServer.PostProcess;
+    Emit(PrimitiveFields('text', N) + Before);
+end;
+
+procedure PcbSave;
+begin
+    if not Ok then Exit;
+    CurBoardDoc.SetModified(True);
+    Emit(FB('saved', CurBoardDoc.DoFileSave('')));
+end;
+
+procedure PcbComponents;
+var
+    It : IPCB_BoardIterator;
+    C  : IPCB_Component;
+begin
+    if not Ok then Exit;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eComponentObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    C := It.FirstPCBObject;
+    while C <> nil do
+    begin
+        Emit(F('designator', C.Name.Text) + F('footprint', C.Pattern)
+            + FI('x', C.X - CurBoard.XOrigin) + FI('y', C.Y - CurBoard.YOrigin)
+            + FI('rotation', Round(C.Rotation)) + FB('bottom', C.Layer = eBottomLayer));
+        C := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+end;
+
+function ShapeName(Shape: Integer): String;
+begin
+    if Shape = eRounded then Result := 'round'
+    else if Shape = eRectangular then Result := 'rect'
+    else if Shape = eOctagonal then Result := 'octagonal'
+    else if Shape = eRoundedRectangular then Result := 'roundrect'
+    else Result := 'other';
+end;
+
+procedure PcbPads;
+var
+    It  : IPCB_BoardIterator;
+    P   : IPCB_Pad;
+    Net, Owner, Stack : String;
+begin
+    if not Ok then Exit;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(ePadObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    P := It.FirstPCBObject;
+    while P <> nil do
+    begin
+        Net := '';
+        if P.Net <> nil then Net := P.Net.Name;
+        Owner := '';
+        if P.Component <> nil then Owner := P.Component.Name.Text;
+        { w, h and shape are the top layer's. A pad with a stack (mode 1 top-middle-bottom, 2 full
+          stack) can differ below: its middle and bottom geometry is reported too. }
+        Stack := FI('stack_mode', P.Mode);
+        if P.Mode <> 0 then
+            Stack := Stack + FI('mid_w', P.MidXSize) + FI('mid_h', P.MidYSize) + F('mid_shape', ShapeName(P.MidShape))
+                + FI('bottom_w', P.BotXSize) + FI('bottom_h', P.BotYSize) + F('bottom_shape', ShapeName(P.BotShape));
+        Emit(F('designator', Owner) + F('pad', P.Name) + F('net', Net)
+            + FI('x', P.X - CurBoard.XOrigin) + FI('y', P.Y - CurBoard.YOrigin)
+            + FI('layer', P.Layer) + FI('hole', P.HoleSize)
+            + FI('w', P.TopXSize) + FI('h', P.TopYSize) + F('shape', ShapeName(P.TopShape))
+            + FI('rotation', Round(P.Rotation))
+            + FI('mask_mode', P.SolderMaskExpansionMode) + FI('mask', P.SolderMaskExpansion)
+            + FI('paste_mode', P.PasteMaskExpansionMode) + FI('paste', P.PasteMaskExpansion) + Stack);
+        P := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+end;
+
+procedure PcbRules;
+var
+    It : IPCB_BoardIterator;
+    R  : IPCB_Rule;
+begin
+    if not Ok then Exit;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eRuleObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    R := It.FirstPCBObject;
+    while R <> nil do
+    begin
+        Emit(F('rule', R.Name) + FI('kind', R.RuleKind) + FI('priority', R.Priority) + FB('enabled', R.Enabled)
+            + F('comment', R.Comment) + F('descriptor', R.Descriptor));
+        R := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+end;
+
+procedure PcbBoardOutline;
+var
+    O   : IPCB_BoardOutline;
+    Seg : TPolySegment;
+    I   : Integer;
+begin
+    if not Ok then Exit;
+    O := CurBoard.BoardOutline;
+    for I := 0 to O.PointCount - 1 do
+    begin
+        { Indexed record fields read inline can come back 0: copy the segment first. }
+        Seg := O.Segments[I];
+        Emit(FI('x', Seg.vx - CurBoard.XOrigin) + FI('y', Seg.vy - CurBoard.YOrigin) + FI('kind', Seg.Kind));
+    end;
+end;
+
+procedure PcbBodies;
+var
+    It : IPCB_BoardIterator;
+    GI : IPCB_GroupIterator;
+    C  : IPCB_Component;
+    O  : IPCB_Primitive;
+    B  : IPCB_ComponentBody;
+    S  : String;
+begin
+    { One item per 3D body of every placed component: the STEP model's file name, or 'extruded'
+      for a body drawn in the footprint, so a footprint update can be checked part by part. }
+    if not Ok then Exit;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eComponentObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    C := It.FirstPCBObject;
+    while C <> nil do
+    begin
+        GI := C.GroupIterator_Create;
+        GI.AddFilter_ObjectSet(MkSet(eComponentBodyObject));
+        O := GI.FirstPCBObject;
+        while O <> nil do
+        begin
+            B := O;
+            S := '';
+            if B.Model <> nil then S := ExtractFileName(B.Model.FileName);
+            if S = '' then S := 'extruded';
+            Emit(F('designator', C.Name.Text) + F('footprint', C.Pattern) + F('model', S)
+                + FI('overall', B.OverallHeight) + FI('standoff', B.StandoffHeight));
+            O := GI.NextPCBObject;
+        end;
+        C.GroupIterator_Destroy(GI);
+        C := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+end;
+
+procedure PcbNets;
+var
+    It : IPCB_BoardIterator;
+    N  : IPCB_Net;
+begin
+    if not Ok then Exit;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eNetObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    N := It.FirstPCBObject;
+    while N <> nil do
+    begin
+        Emit(F('net', N.Name));
+        N := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+end;
+
+procedure PcbRuleVia(Name, Scope: String; HoleMin, HolePref, HoleMax, DiaMin, DiaPref, DiaMax: Integer);
+var
+    R : IPCB_RoutingViaStyleRule;
+begin
+    if not Ok then Exit;
+    DropRule(Name);
+    R := PCBServer.PCBRuleFactory(eRule_RoutingViaStyle);
+    R.Name := Name;
+    R.Scope1Expression := Scope;
+    R.MinHoleWidth := HoleMin;
+    R.PreferedHoleWidth := HolePref;
+    R.MaxHoleWidth := HoleMax;
+    R.MinWidth := DiaMin;
+    R.PreferedWidth := DiaPref;
+    R.MaxWidth := DiaMax;
+    CurBoard.AddPCBObject(R);
+    Emit(F('rule', Name));
+end;
+
+procedure PcbRuleValue(Name: String; Kind: Integer; Scope1, Scope2: String; Value, Value2: Integer);
+var
+    R : IPCB_Rule;
+begin
+    { Rule kinds whose value is one length: 12 PlaneClearance, 13 SolderMaskExpansion,
+      14 PasteMaskExpansion, 24 ComponentClearance (Value2 = vertical gap), 52 HoleToHoleClearance. }
+    if not Ok then Exit;
+    DropRule(Name);
+    R := PCBServer.PCBRuleFactory(Kind);
+    R.Name := Name;
+    R.Scope1Expression := Scope1;
+    R.Scope2Expression := Scope2;
+    case Kind of
+        12: R.Clearance := Value;
+        13, 14: R.Expansion := Value;
+        24: begin R.Gap := Value; R.VerticalGap := Value2; end;
+        52: R.Gap := Value;
+    else
+        begin Fail('rule kind ' + IntToStr(Kind) + ' is not a single-value rule'); Exit; end;
+    end;
+    CurBoard.AddPCBObject(R);
+    Emit(F('rule', Name));
+end;
+
+procedure PcbRuleDelete(Name: String);
+begin
+    if not Ok then Exit;
+    Emit(F('rule', Name) + FB('deleted', DropRule(Name)));
+end;
+
+procedure PcbPlaneNet(Layer: Integer; Net: String; PullBack: Integer);
+var
+    LO : IPCB_LayerObject_V7;
+begin
+    if not Ok then Exit;
+    if FindNet(Net) = nil then begin Fail('no net ' + Net + ' on the board'); Exit; end;
+    LO := CurBoard.LayerStack_V7.LayerObject_V7[Layer];
+    if LO = nil then begin Fail('layer ' + IntToStr(Layer) + ' is not in the stack (pcb_add_layer first)'); Exit; end;
+    LO.NetName := Net;
+    LO.PullBackDistance := PullBack;
+    CurBoard.ViewManager_FullUpdate;
+    Emit(FI('layer', Layer) + F('net', LO.NetName));
+end;
+
+procedure PcbDielectric(Layer, Height, Copper: Integer);
+var
+    LO : IPCB_LayerObject_V7;
+begin
+    { The copper thickness of one stack layer and the height of the dielectric below it. }
+    if not Ok then Exit;
+    LO := CurBoard.LayerStack_V7.LayerObject_V7[Layer];
+    if LO = nil then begin Fail('layer ' + IntToStr(Layer) + ' is not in the stack (pcb_add_layer first)'); Exit; end;
+    if LO.Dielectric = nil then begin Fail('layer ' + IntToStr(Layer) + ' has no dielectric below it'); Exit; end;
+    LO.Dielectric.DielectricHeight := Height;
+    LO.CopperThickness := Copper;
+    CurBoard.ViewManager_FullUpdate;
+    Emit(FI('layer', Layer) + FI('height', LO.Dielectric.DielectricHeight) + FI('copper', LO.CopperThickness));
+end;
+
+procedure PcbCopper(Layer, Copper: Integer);
+var
+    LO : IPCB_LayerObject_V7;
+begin
+    { The copper thickness of one stack layer alone (pcb_dielectric needs a dielectric below, which
+      the bottom layer has not). }
+    if not Ok then Exit;
+    LO := CurBoard.LayerStack_V7.LayerObject_V7[Layer];
+    if LO = nil then begin Fail('layer ' + IntToStr(Layer) + ' is not in the stack (pcb_add_layer first)'); Exit; end;
+    LO.CopperThickness := Copper;
+    CurBoard.ViewManager_FullUpdate;
+    Emit(FI('layer', Layer) + FI('copper', LO.CopperThickness));
+end;
+
+procedure PcbDeleteTrack(Layer, X1, Y1, X2, Y2: Integer);
+var
+    It : IPCB_BoardIterator;
+    T  : IPCB_Track;
+    L  : TInterfaceList;
+    I  : Integer;
+    Ax, Ay, Bx, By, Tol : Integer;
+begin
+    { One track, named by its end points (either direction, 0.01 mm tolerance). Fails when no
+      track matches, so a stale coordinate never passes silently. }
+    if not Ok then Exit;
+    Tol := 3937;
+    Ax := CurBoard.XOrigin + X1; Ay := CurBoard.YOrigin + Y1;
+    Bx := CurBoard.XOrigin + X2; By := CurBoard.YOrigin + Y2;
+    L := TInterfaceList.Create;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eTrackObject));
+    It.AddFilter_LayerSet(MkSet(Layer));
+    It.AddFilter_Method(eProcessAll);
+    T := It.FirstPCBObject;
+    while T <> nil do
+    begin
+        if (T.Layer = Layer) and (
+            ((Abs(T.x1 - Ax) <= Tol) and (Abs(T.y1 - Ay) <= Tol) and (Abs(T.x2 - Bx) <= Tol) and (Abs(T.y2 - By) <= Tol)) or
+            ((Abs(T.x1 - Bx) <= Tol) and (Abs(T.y1 - By) <= Tol) and (Abs(T.x2 - Ax) <= Tol) and (Abs(T.y2 - Ay) <= Tol))) then
+            L.Add(T);
+        T := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+    if L.Count = 0 then begin L.Free; Fail('no track with those end points on that layer'); Exit; end;
+    PCBServer.PreProcess;
+    for I := 0 to L.Count - 1 do CurBoard.RemovePCBObject(L.Items[I]);
+    PCBServer.PostProcess;
+    Emit(FI('removed', L.Count));
+    L.Free;
+end;
+
+procedure PcbDeleteVia(X, Y: Integer; Net: String);
+var
+    It : IPCB_BoardIterator;
+    V  : IPCB_Via;
+    L  : TInterfaceList;
+    I, Ax, Ay, Tol : Integer;
+begin
+    { The vias at one point (0.01 mm tolerance), optionally only of one net. Fails when none
+      matches, so a stale coordinate never passes silently. }
+    if not Ok then Exit;
+    Tol := 3937;
+    Ax := CurBoard.XOrigin + X; Ay := CurBoard.YOrigin + Y;
+    L := TInterfaceList.Create;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eViaObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    V := It.FirstPCBObject;
+    while V <> nil do
+    begin
+        if (Abs(V.x - Ax) <= Tol) and (Abs(V.y - Ay) <= Tol) and ((Net = '') or SameText(NetName(V), Net)) then
+            L.Add(V);
+        V := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+    if L.Count = 0 then begin L.Free; Fail('no via at that point'); Exit; end;
+    PCBServer.PreProcess;
+    for I := 0 to L.Count - 1 do CurBoard.RemovePCBObject(L.Items[I]);
+    PCBServer.PostProcess;
+    Emit(FI('removed', L.Count));
+    L.Free;
+end;
+
+function NearPoint(X, Y, Px, Py, Tol: Integer): Boolean;
+begin
+    Result := (Abs(X - Px) <= Tol) and (Abs(Y - Py) <= Tol);
+end;
+
+procedure PcbTrackEnd(Net: String; Layer, X, Y, ToX, ToY: Integer);
+var
+    It : IPCB_BoardIterator;
+    T  : IPCB_Track;
+    L1, L2 : TInterfaceList;
+    I, Ax, Ay, Bx, By, Tol, Skipped : Integer;
+begin
+    { Move the track ends of Net on Layer that lie within 0.01 mm of (X, Y), and not on
+      (ToX, ToY) already, to (ToX, ToY): joins an autorouter left a fraction of a micron apart
+      (reported as net antennae) become one point. A track whose other end is the target is left
+      alone (moving it would leave no track). Width, net and lock stay. Fails when no end moves. }
+    if not Ok then Exit;
+    Tol := 3937;
+    Skipped := 0;
+    Ax := CurBoard.XOrigin + X; Ay := CurBoard.YOrigin + Y;
+    Bx := CurBoard.XOrigin + ToX; By := CurBoard.YOrigin + ToY;
+    L1 := TInterfaceList.Create;
+    L2 := TInterfaceList.Create;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eTrackObject));
+    It.AddFilter_LayerSet(MkSet(Layer));
+    It.AddFilter_Method(eProcessAll);
+    T := It.FirstPCBObject;
+    while T <> nil do
+    begin
+        if (T.Layer = Layer) and SameText(NetName(T), Net) then
+        begin
+            if NearPoint(T.x1, T.y1, Ax, Ay, Tol) and not ((T.x1 = Bx) and (T.y1 = By)) then
+            begin
+                if NearPoint(T.x2, T.y2, Bx, By, 0) then Skipped := Skipped + 1 else L1.Add(T);
+            end;
+            if NearPoint(T.x2, T.y2, Ax, Ay, Tol) and not ((T.x2 = Bx) and (T.y2 = By)) then
+            begin
+                if NearPoint(T.x1, T.y1, Bx, By, 0) then Skipped := Skipped + 1 else L2.Add(T);
+            end;
+        end;
+        T := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+    if L1.Count + L2.Count = 0 then
+    begin
+        L1.Free; L2.Free;
+        Fail('no track end of that net to move at that point on that layer (' + IntToStr(Skipped) + ' would collapse)');
+        Exit;
+    end;
+    PCBServer.PreProcess;
+    for I := 0 to L1.Count - 1 do
+    begin
+        T := L1.Items[I];
+        PCBServer.SendMessageToRobots(T.I_ObjectAddress, c_Broadcast, PCBM_BeginModify, c_NoEventData);
+        T.x1 := Bx; T.y1 := By;
+        PCBServer.SendMessageToRobots(T.I_ObjectAddress, c_Broadcast, PCBM_EndModify, c_NoEventData);
+    end;
+    for I := 0 to L2.Count - 1 do
+    begin
+        T := L2.Items[I];
+        PCBServer.SendMessageToRobots(T.I_ObjectAddress, c_Broadcast, PCBM_BeginModify, c_NoEventData);
+        T.x2 := Bx; T.y2 := By;
+        PCBServer.SendMessageToRobots(T.I_ObjectAddress, c_Broadcast, PCBM_EndModify, c_NoEventData);
+    end;
+    PCBServer.PostProcess;
+    Emit(FI('moved', L1.Count + L2.Count) + FI('skipped', Skipped));
+    L1.Free;
+    L2.Free;
+end;
+
+procedure PcbUnroute(Csv: String; IncludeLocked: Boolean);
+var
+    It   : IPCB_BoardIterator;
+    O    : IPCB_Primitive;
+    L    : TInterfaceList;
+    SL   : TStringList;
+    I, K : Integer;
+begin
+    if not Ok then Exit;
+    SL := TStringList.Create;
+    SL.Delimiter := ',';
+    SL.StrictDelimiter := True;
+    SL.DelimitedText := Csv;
+    L := TInterfaceList.Create;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eTrackObject, eArcObject, eViaObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    O := It.FirstPCBObject;
+    while O <> nil do
+    begin
+        if (O.Net <> nil) and (SL.IndexOf(O.Net.Name) >= 0) and (IncludeLocked or O.Moveable) then L.Add(O);
+        O := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+    PCBServer.PreProcess;
+    for I := 0 to L.Count - 1 do CurBoard.RemovePCBObject(L.Items[I]);
+    PCBServer.PostProcess;
+    K := L.Count;
+    L.Free;
+    SL.Free;
+    CurBoard.ViewManager_FullUpdate;
+    Emit(FI('removed', K));
+end;
+
+procedure PcbRuleHoleSize(Name: String; MinH, MaxH: Integer);
+var
+    R : IPCB_Rule;
+begin
+    if not Ok then Exit;
+    DropRule(Name);
+    R := PCBServer.PCBRuleFactory(42);   { eRule_MaxMinHoleSize }
+    R.Name := Name;
+    R.Scope1Expression := 'All';
+    R.MinLimit := MinH;
+    R.MaxLimit := MaxH;
+    CurBoard.AddPCBObject(R);
+    Emit(F('rule', Name));
+end;
+
+procedure PcbRuleRoutingLayers(Name, Scope, Layers: String);
+var
+    R  : IPCB_Rule;
+    LO : IPCB_LayerObject_V7;
+    S  : String;
+begin
+    { Which signal layers the router may use; Layers lists layer numbers between bars ("|1|32|").
+      Every other signal layer in the stack is switched off for this rule. }
+    if not Ok then Exit;
+    DropRule(Name);
+    R := PCBServer.PCBRuleFactory(eRule_RoutingLayers);
+    R.Name := Name;
+    R.Scope1Expression := Scope;
+    S := '';
+    LO := CurBoard.LayerStack_V7.FirstLayer;
+    while LO <> nil do
+    begin
+        if (LO.LayerID >= eTopLayer) and (LO.LayerID <= eBottomLayer) then
+        begin
+            R.RoutingLayers[LO.LayerID] := Pos('|' + IntToStr(LO.LayerID) + '|', Layers) > 0;
+            if R.RoutingLayers[LO.LayerID] then S := S + LO.Name + ';';
+        end;
+        LO := CurBoard.LayerStack_V7.NextLayer(LO);
+    end;
+    CurBoard.AddPCBObject(R);
+    Emit(F('rule', Name) + F('layers', S));
+end;
+
+procedure PcbRuleCorners(Name, Scope: String; Style, MinSetBack, MaxSetBack: Integer);
+var
+    R : IPCB_Rule;
+begin
+    { Routing Corners: the corner style Situs and interactive routing use. Style 0 = 90 degrees,
+      1 = 45 degrees, 2 = rounded; the setbacks size the 45-degree chamfer or the arc. }
+    if not Ok then Exit;
+    DropRule(Name);
+    R := PCBServer.PCBRuleFactory(10);   { eRule_RoutingCorners }
+    R.Name := Name;
+    R.Scope1Expression := Scope;
+    R.Style := Style;
+    R.MinSetBack := MinSetBack;
+    R.MaxSetBack := MaxSetBack;
+    CurBoard.AddPCBObject(R);
+    Emit(F('rule', Name) + F('summary', R.GetState_DataSummaryString));
+end;
+
+procedure PcbRulePriority(Name, Scope: String; Priority: Integer);
+var
+    R : IPCB_Rule;
+begin
+    { Routing Priority: Situs routes nets with a higher priority (0-100) first. }
+    if not Ok then Exit;
+    DropRule(Name);
+    R := PCBServer.PCBRuleFactory(8);    { eRule_RoutingPriority }
+    R.Name := Name;
+    R.Scope1Expression := Scope;
+    R.RoutingPriority := Priority;
+    CurBoard.AddPCBObject(R);
+    Emit(F('rule', Name) + F('summary', R.GetState_DataSummaryString));
+end;
+
+procedure PcbRuleTopology(Name, Scope: String; Topology: Integer);
+var
+    R : IPCB_Rule;
+begin
+    { Routing Topology: the order in which Situs joins a net's pins (0 = shortest). }
+    if not Ok then Exit;
+    DropRule(Name);
+    R := PCBServer.PCBRuleFactory(7);    { eRule_RoutingTopology }
+    R.Name := Name;
+    R.Scope1Expression := Scope;
+    R.Topology := Topology;
+    CurBoard.AddPCBObject(R);
+    Emit(F('rule', Name) + F('summary', R.GetState_DataSummaryString));
+end;
+
+function DropDiffPair(Name: String): Integer;
+var
+    It : IPCB_BoardIterator;
+    D  : IPCB_DifferentialPair;
+    L  : TInterfaceList;
+    I  : Integer;
+begin
+    L := TInterfaceList.Create;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eDifferentialPairObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    D := It.FirstPCBObject;
+    while D <> nil do
+    begin
+        if SameText(D.Name, Name) then L.Add(D);
+        D := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+    for I := 0 to L.Count - 1 do CurBoard.RemovePCBObject(L.Items[I]);
+    Result := L.Count;
+    L.Free;
+end;
+
+procedure PcbDiffPairs;
+var
+    It : IPCB_BoardIterator;
+    D  : IPCB_DifferentialPair;
+    P, N : String;
+begin
+    if not Ok then Exit;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eDifferentialPairObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    D := It.FirstPCBObject;
+    while D <> nil do
+    begin
+        P := ''; N := '';
+        if D.PositiveNet <> nil then P := D.PositiveNet.Name;
+        if D.NegativeNet <> nil then N := D.NegativeNet.Name;
+        Emit(F('pair', D.Name) + F('positive', P) + F('negative', N));
+        D := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+end;
+
+procedure PcbDiffPair(Name, PosNet, NegNet: String);
+var
+    D    : IPCB_DifferentialPair;
+    P, N : IPCB_Net;
+    Replaced : Integer;
+begin
+    { A differential pair object: the rule scope IsDifferentialPair / InDifferentialPair('Name')
+      and the interactive pair router act on these, not on net names. Same name = replaced. }
+    if not Ok then Exit;
+    P := FindNet(PosNet);
+    N := FindNet(NegNet);
+    if P = nil then begin Fail('no net ' + PosNet + ' on the board'); Exit; end;
+    if N = nil then begin Fail('no net ' + NegNet + ' on the board'); Exit; end;
+    Replaced := DropDiffPair(Name);
+    PCBServer.PreProcess;
+    D := PCBServer.PCBObjectFactory(eDifferentialPairObject, eNoDimension, eCreate_Default);
+    D.Name := Name;
+    D.PositiveNet := P;
+    D.NegativeNet := N;
+    CurBoard.AddPCBObject(D);
+    PCBServer.PostProcess;
+    Emit(F('pair', Name) + F('positive', P.Name) + F('negative', N.Name) + FI('replaced', Replaced));
+end;
+
+procedure PcbRuleDiffPair(Name, Scope: String; MinW, PrefW, MaxW, MinG, PrefG, MaxG, Uncoupled: Integer);
+var
+    R : IPCB_Rule;
+    L : Integer;
+begin
+    { Differential Pairs Routing: width and gap per signal layer, and the longest stretch the pair
+      may run uncoupled (at connectors and pads). }
+    if not Ok then Exit;
+    DropRule(Name);
+    R := PCBServer.PCBRuleFactory(51);   { eRule_DifferentialPairsRouting, between fan-out height 50 and hole-to-hole 52 }
+    R.Name := Name;
+    R.Scope1Expression := Scope;
+    for L := eTopLayer to eBottomLayer do
+    begin
+        R.MinWidth[L] := MinW;
+        R.PreferedWidth[L] := PrefW;
+        R.MaxWidth[L] := MaxW;
+        R.MinGap[L] := MinG;
+        R.PreferedGap[L] := PrefG;
+        R.MaxGap[L] := MaxG;
+    end;
+    R.MaxUncoupledLength := Uncoupled;
+    CurBoard.AddPCBObject(R);
+    Emit(F('rule', Name) + F('summary', R.GetState_DataSummaryString) + FI('uncoupled_max', R.MaxUncoupledLength));
+end;
+
+procedure PcbRulePlaneConnect(Name, Scope: String; Style, Conductor, Entries, AirGap, Expansion: Integer);
+var
+    R : IPCB_Rule;
+begin
+    { Power Plane Connect Style: how pads and vias join an internal plane. Style 0 = relief,
+      1 = direct, 2 = no connect (TPlaneConnectStyle). }
+    if not Ok then Exit;
+    DropRule(Name);
+    R := PCBServer.PCBRuleFactory(6);    { eRule_PowerPlaneConnectStyle }
+    R.Name := Name;
+    R.Scope1Expression := Scope;
+    R.PlaneConnectStyle := Style;
+    R.ReliefConductorWidth := Conductor;
+    R.ReliefEntries := Entries;
+    R.ReliefAirGap := AirGap;
+    R.ReliefExpansion := Expansion;
+    CurBoard.AddPCBObject(R);
+    Emit(F('rule', Name) + F('summary', R.GetState_DataSummaryString));
+end;
+
+procedure PcbRulePolygonConnect(Name, Scope: String; Style, Conductor, Entries, Angle, AirGap: Integer);
+var
+    R : IPCB_Rule;
+begin
+    { Polygon Connect Style: how pads and vias join a polygon pour. Style as for planes; Angle 45
+      or 90 degrees for the relief spokes. }
+    if not Ok then Exit;
+    DropRule(Name);
+    R := PCBServer.PCBRuleFactory(20);   { eRule_PolygonConnectStyle }
+    R.Name := Name;
+    R.Scope1Expression := Scope;
+    R.ConnectStyle := Style;
+    R.ReliefConductorWidth := Conductor;
+    R.ReliefEntries := Entries;
+    R.PolygonReliefAngle := Angle;
+    R.ReliefAirGap := AirGap;
+    CurBoard.AddPCBObject(R);
+    Emit(F('rule', Name) + F('summary', R.GetState_DataSummaryString) + FI('relief_angle', R.PolygonReliefAngle));
+end;
+
+procedure PcbRuleSilkToSilk(Name: String; Gap: Integer);
+var
+    R : IPCB_Rule;
+begin
+    if not Ok then Exit;
+    DropRule(Name);
+    R := PCBServer.PCBRuleFactory(55);   { eRule_SilkToSilkClearance }
+    R.Name := Name;
+    R.Scope1Expression := 'All';
+    R.Scope2Expression := 'All';
+    R.SilkToSilkClearance := Gap;
+    CurBoard.AddPCBObject(R);
+    Emit(F('rule', Name));
+end;
+
+procedure PcbRuleMaskSliver(Name: String; Gap: Integer);
+var
+    R : IPCB_Rule;
+begin
+    if not Ok then Exit;
+    DropRule(Name);
+    R := PCBServer.PCBRuleFactory(53);   { eRule_MinimumSolderMaskSliver }
+    R.Name := Name;
+    R.Scope1Expression := 'All';
+    R.Scope2Expression := 'All';
+    R.MinSolderMaskSliver := Gap;
+    CurBoard.AddPCBObject(R);
+    Emit(F('rule', Name));
+end;
+
+procedure PcbTentVias(Top, Bottom: Boolean);
+var
+    It : IPCB_BoardIterator;
+    V  : IPCB_Via;
+    L  : TInterfaceList;
+    I  : Integer;
+begin
+    if not Ok then Exit;
+    { Collect first: a primitive modified during iteration is re-indexed and visited again,
+      which never ends. }
+    L := TInterfaceList.Create;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eViaObject));
+    It.AddFilter_LayerSet(AllLayers);
+    It.AddFilter_Method(eProcessAll);
+    V := It.FirstPCBObject;
+    while V <> nil do begin L.Add(V); V := It.NextPCBObject; end;
+    CurBoard.BoardIterator_Destroy(It);
+    PCBServer.PreProcess;
+    for I := 0 to L.Count - 1 do
+    begin
+        V := L.Items[I];
+        PCBServer.SendMessageToRobots(V.I_ObjectAddress, c_Broadcast, PCBM_BeginModify, c_NoEventData);
+        { Tenting flags are ignored while the via follows the mask expansion rule (mode 1). }
+        V.SolderMaskExpansionMode := 2;
+        V.IsTenting_Top := Top;
+        V.IsTenting_Bottom := Bottom;
+        PCBServer.SendMessageToRobots(V.I_ObjectAddress, c_Broadcast, PCBM_EndModify, c_NoEventData);
+    end;
+    PCBServer.PostProcess;
+    Emit(FI('vias', L.Count));
+    L.Free;
+end;
+
+procedure PcbClearTexts(Layer: Integer);
+var
+    It : IPCB_BoardIterator;
+    T  : IPCB_Text;
+    L  : TInterfaceList;
+    I  : Integer;
+begin
+    { Free texts only: designators and comments belong to their components. Lets a script
+      that writes silk text be re-run without stacking duplicates. }
+    if not Ok then Exit;
+    L := TInterfaceList.Create;
+    It := CurBoard.BoardIterator_Create;
+    It.AddFilter_ObjectSet(MkSet(eTextObject));
+    It.AddFilter_LayerSet(MkSet(Layer));
+    It.AddFilter_Method(eProcessAll);
+    T := It.FirstPCBObject;
+    while T <> nil do
+    begin
+        if (not T.InComponent) and (T.Layer = Layer) then L.Add(T);
+        T := It.NextPCBObject;
+    end;
+    CurBoard.BoardIterator_Destroy(It);
+    PCBServer.PreProcess;
+    for I := 0 to L.Count - 1 do CurBoard.RemovePCBObject(L.Items[I]);
+    PCBServer.PostProcess;
+    Emit(FI('layer', Layer) + FI('removed', L.Count));
+    L.Free;
+end;
+
+procedure PcbClearLayer(Layer: Integer);
+var
+    It   : IPCB_BoardIterator;
+    O    : IPCB_Primitive;
+    L    : TInterfaceList;
+    I    : Integer;
+    Pass : Integer;
+begin
+    { Free tracks, arcs and regions on one layer (no net, not part of a component or polygon),
+      e.g. an outline drawn on a mechanical layer or a logo on an overlay, so a script can redraw
+      it without stacking copies. Board regions (Kind 3, the shape that carries the layer stack)
+      are never drawings: regions are read in their own pass, where Kind is defined. }
+    if not Ok then Exit;
+    L := TInterfaceList.Create;
+    for Pass := 0 to 1 do
+    begin
+        It := CurBoard.BoardIterator_Create;
+        if Pass = 0 then It.AddFilter_ObjectSet(MkSet(eTrackObject, eArcObject))
+        else It.AddFilter_ObjectSet(MkSet(eRegionObject));
+        It.AddFilter_LayerSet(MkSet(Layer));
+        It.AddFilter_Method(eProcessAll);
+        O := It.FirstPCBObject;
+        while O <> nil do
+        begin
+            if (O.Layer = Layer) and (O.Net = nil) and (not O.InComponent) and (not O.InPolygon) then
+            begin
+                if Pass = 0 then L.Add(O)
+                else if O.Kind <> 3 then L.Add(O);
+            end;
+            O := It.NextPCBObject;
+        end;
+        CurBoard.BoardIterator_Destroy(It);
+    end;
+    PCBServer.PreProcess;
+    for I := 0 to L.Count - 1 do CurBoard.RemovePCBObject(L.Items[I]);
+    PCBServer.PostProcess;
+    Emit(FI('layer', Layer) + FI('removed', L.Count));
+    L.Free;
+end;
+
+procedure PcbRemoveComponents(Csv: String);
+var
+    SL : TStringList;
+    C  : IPCB_Component;
+    I, K : Integer;
+begin
+    if not Ok then Exit;
+    SL := TStringList.Create;
+    SL.Delimiter := ',';
+    SL.StrictDelimiter := True;
+    SL.DelimitedText := Csv;
+    K := 0;
+    PCBServer.PreProcess;
+    for I := 0 to SL.Count - 1 do
+    begin
+        C := FindPcbComp(SL[I]);
+        if C <> nil then begin CurBoard.RemovePCBObject(C); K := K + 1; end;
+    end;
+    PCBServer.PostProcess;
+    CurBoard.ViewManager_FullUpdate;
+    Emit(FI('removed', K));
+    SL.Free;
+end;
+
+procedure PcbDesignator(Des: String; Show: Boolean; X, Y, Height, Rot: Integer);
+var
+    C : IPCB_Component;
+begin
+    if not Ok then Exit;
+    C := FindPcbComp(Des);
+    if C = nil then begin Fail('no component ' + Des + ' on the board'); Exit; end;
+    PCBServer.PreProcess;
+    PCBServer.SendMessageToRobots(C.I_ObjectAddress, c_Broadcast, PCBM_BeginModify, c_NoEventData);
+    C.NameOn := Show;
+    if Show then
+    begin
+        C.NameAutoPosition := eAutoPos_Manual;
+        C.Name.Size := Height;
+        C.Name.Width := Height div 7;
+        C.Name.Rotation := Rot;
+        C.Name.MoveToXY(CurBoard.XOrigin + X, CurBoard.YOrigin + Y);
+    end;
+    PCBServer.SendMessageToRobots(C.I_ObjectAddress, c_Broadcast, PCBM_EndModify, c_NoEventData);
+    PCBServer.PostProcess;
+    Emit(F('designator', Des) + FB('shown', C.NameOn));
+end;
+
+procedure PcbAddLayer(Layer: Integer);
+var
+    LS    : IPCB_LayerStack_V7;
+    LO    : IPCB_LayerObject_V7;
+    Found : Boolean;
+begin
+    if not Ok then Exit;
+    LS := CurBoard.LayerStack_V7;
+    Found := False;
+    LO := LS.FirstLayer;
+    while LO <> nil do
+    begin
+        if LO.LayerID = Layer then Found := True;
+        LO := LS.NextLayer(LO);
+    end;
+    if not Found then LS.InsertLayer(Layer);
+    CurBoard.ViewManager_FullUpdate;
+    Emit(FI('layer', Layer) + FB('added', not Found));
+end;
+
+procedure PcbLayers;
+var
+    LS   : IPCB_LayerStack_V7;
+    LO   : IPCB_LayerObject_V7;
+    Next : IPCB_LayerObject_V7;
+begin
+    if not Ok then Exit;
+    LS := CurBoard.LayerStack_V7;
+    LO := LS.FirstLayer;
+    while LO <> nil do
+    begin
+        { The dielectric below a layer counts only between copper layers: Altium reports one under
+          the bottom layer too, but leaves it out of the board thickness. }
+        Next := LS.NextLayer(LO);
+        if (Next <> nil) and (LO.Dielectric <> nil) then
+            Emit(F('layer', LO.Name) + FI('id', LO.LayerID) + FI('copper', LO.CopperThickness)
+                 + FI('dielectric', LO.Dielectric.DielectricHeight))
+        else
+            Emit(F('layer', LO.Name) + FI('id', LO.LayerID) + FI('copper', LO.CopperThickness));
+        LO := Next;
+    end;
+end;
+
+{ ------------------------------------------------------------------ outputs --- }
+
+procedure SaveProjectFile(PrjPath: String);
+var
+    SD : IServerDocument;
+begin
+    { Binding an OutJob changes the project file while its Modified flag may read False: save that
+      file. The design documents are not saved. Saving every loaded document after a run rewrote
+      the PCB, schematics, libraries, drawings and BOM of an Altium 365 working copy with new GUIDs,
+      timestamps and prices, and the same design. The "Unsaved Changes" prompt a run can leave is
+      answered "Don't Save" by the drive, which refuses a run while the project holds unsaved edits. }
+    SD := Client.GetDocumentByPath(PrjPath);
+    if SD <> nil then begin SD.SetModified(True); SD.DoFileSave(''); end;
+end;
+
+procedure OutJobRun(OutJob, PrjPath, Medium: String);
+var
+    SD : IServerDocument;
+begin
+    if not Ok then Exit;
+    { Adding the OutJob modifies the project; save it before anything closes, or Altium asks. }
+    if PrjPath <> '' then
+    begin
+        BindToProject(OutJob, PrjPath);
+        if not Ok then Exit;  { the project is not open: generate nothing }
+        SaveProjectFile(PrjPath);
+    end;
+    { The OutJob file on disk is the drive's: close an open copy without saving, so Altium loads the
+      file as written. Altium's own save rewrote it with defaults, absolute paths and another section
+      order on every run, a working-copy change each time. }
+    CloseDocPath(OutJob, False);
+    SD := ShowDoc('OUTPUTJOB', OutJob);
+    if SD = nil then begin Fail('cannot open OutJob ' + OutJob); Exit; end;
+    ResetParameters;
+    if Copy(Medium, 1, 3) = 'PDF' then
+    begin
+        { A Publish medium (named PDF...) prints rather than generates; no dialog, no overwrite prompt. }
+        AddStringParameter('Action', 'PublishToPDF');
+        AddStringParameter('OutputMedium', Medium);
+        AddStringParameter('ObjectKind', 'OutputBatch');
+        AddStringParameter('DisableDialog', 'True');
+        AddStringParameter('PromptOverwrite', 'FALSE');
+        RunProcess('WorkspaceManager:Print');
+    end
+    else
+    begin
+        AddStringParameter('Action', 'Run');
+        AddStringParameter('OutputMedium', Medium);
+        AddStringParameter('ObjectKind', 'OutputBatch');
+        RunProcess('WorkspaceManager:GenerateReport');
+    end;
+    { Leave no OutJob editor in front: a later screenshot of a schematic or PCB would catch it. }
+    if PrjPath <> '' then SaveProjectFile(PrjPath);
+    CloseDocPath(OutJob, False);
+    Emit(F('outjob', OutJob) + F('medium', Medium));
+end;