SOFTrobots OS · App-API

Stand 14. November 2026 · App-API 1 · Entwurf bis Release 1.0.0 – Deklarationen können sich noch ändern; Programme werden dann neu gebaut, nicht kompatibel gehalten · neu gegliedert nach Modulen (Rechte · Systemaufrufe · Swift), App-API, System-API und Bibliotheken getrennt · 1078 Deklarationen in docs/api/app-api-1.txt, 874 in docs/api/libraries.txt

Überblick

Drei Ebenen

Rechte im signierten Manifest (capabilities = …, 32 Namen) · Systemaufrufe in shapes/*.shape (138 Aufrufe in 24 Modulen, dazu 14 primitive) · Swift für Programme (SOFTrobotsKit). Der Kern prüft jeden Systemaufruf gegen die Rechte; Swift ruft die Systemaufrufe.

Ein Modul, ein Name

Jeder Bereich hat auf allen drei Ebenen denselben Namen: das Präfix der Rechte, das Systemaufruf-Modul und der Swift-Namensraum (network.outgoing · network.connect · Network.Connection). Swift steht hier immer mit vollem Namen (Database.Query.where(_:), nie nur where(_:)).

App-API · System-API · Bibliotheken

App-API: was jedes Programm nutzen darf – Aufrufe ohne Recht oder mit einem der 9 Rechte, die ein normales Programm haben kann (Capability.fromDevelop). System-API (grau markiert): alles, was eines der übrigen 23 Rechte braucht – nur für Systemprogramme. Bibliotheken: Werkzeuge wie Web, Bilder, SVG, die ein Programm per uses-…-Datei mitbaut.

So liest man einen Eintrag

Je Modul drei Teile: Rechte, Systemaufrufe (mit dem Recht, das jeder braucht) und Swift nach Aufgaben. Eine Swift-Zeile: voller Name und Signatur, eine Zeile Erklärung, rechts der Systemaufruf dahinter mit ≤ 2 ms Zeitbudget (die längste Laufzeit, die der Kern zusagt) und Kennung. Darunter ein zugeklapptes Beispiel, meist aus echten Programmen (apps/…), sonst als „Muster“ markiert. neu = seit 10. oder 11.11.

Was zu 1.0 eingefroren wird

Nur die App-API: ab Release 1.0.0 bleiben ihre Namen, Argumentnamen und Typen, Neues kommt nur dazu (make api-check gegen docs/api/app-api-1.txt, 1078 Deklarationen). Bis dahin ist alles ein Entwurf: Programme werden neu gebaut, nicht kompatibel gehalten. Die System-API und die Bibliotheken (docs/api/libraries.txt, 874 Deklarationen) dürfen sich weiter ändern.

Umbenannt am 11.11.

EbeneAltNeu
Rechtapps.launchprograms.launch
Rechtdevelop.buildprograms.build
Rechtdevice.cameracamera.use
Rechtdevice.microphonesound.microphone
Rechtmicrophone.providesound.microphone.provide
Rechtinput.receiveui.input
Rechtinput.provideui.input.provide
Rechtdisplay.ownui.display
Rechtipcchannels.ipc
Systemaufruf-Modulnet.* (net.receive, net.connect …)network.* (network.receive, network.connect …)
Systemaufruf-Moduldb.* (db.open, db.query …)database.* (database.open, database.query …)
SwiftAppsPrograms
SwiftFileFiles.Handle
SwiftWriteSetDatabase.Write
SwiftQueryDatabase.Query
SwiftQueryPageDatabase.Page
SwiftNetConnectionNetwork.Connection
SwiftNetPeerNetwork.Peer
SwiftNetListenerNetwork.Listener
SwiftDatagramSocketNetwork.Datagram
SwiftSoundOutputSound.Output
SwiftMicrophoneSound.Microphone
SwiftMicrophoneInfoSound.MicrophoneInfo
SwiftMicrophoneRingSound.MicrophoneRing

Andere Namen blieben (z. B. Surface, Canvas, Camera, ArmModel, Channel); die Kennungen der Module sind gleich. Diese Tabelle nennt die alten Namen absichtlich; sonst kommen sie auf dieser Seite nicht mehr vor.

45 Abschnitte · App-API: 15 Module, 9 Rechte, 82 Systemaufrufe, 942 Swift-Deklarationen · System-API: 23 Rechte, 56 Systemaufrufe, 136 Deklarationen · Bibliotheken: 10, 874 Deklarationen · 515 erklärte Einträge · 243 Beispiele

Manifest & Profile

Ein Programm bekommt Rechte nur über sein Manifest (Datei manifest im Programmordner, signiert beim Bauen). Die Zeile capabilities = … nennt die Rechte; der Kern prüft jeden Aufruf dagegen. Ein unbekanntes Recht macht das Manifest ungültig – ein Programm bekommt nie ein Recht, das der Kern nicht versteht. Ein Aufruf ohne Rechtevermerk in dieser Übersicht ist jedem Programm offen.

Dazu kommen die Profil-Dateien uses-… im Programmordner: Sie entscheiden, welche Bibliotheken mitgebaut werden (Heap, Oberfläche, Bilder, TLS …). Ohne uses-heap ist ein Programm im Echtzeit-Profil (-no-allocations).

Die Rechte selbst stehen jetzt bei ihren Modulen: die 9 für jedes Programm in der App-API, die übrigen 23 in der System-API (Übersicht dort).

ManifestManifest-Zeilen

AufrufWas er tutShape-Aufruf · Zeitbudget
Identität
name = helloProgrammname (Pflicht).
id = de.softrobots.helloIdentität als umgekehrte Domain (Pflicht seit 08.11.); Datenordner ist /data/<id>.
version = 1.0.3Version (Pflicht); ersetzt wird ein Programm nur durch eine höhere.
api = 1App-API-Version, für die gebaut wurde; ein System, das weniger bietet, startet es nicht.
Rechte & Dokumente
capabilities = system.log, ui.surfaceDie Rechte des Programms (Tabelle unten).
opens = txt, mdDokumenttypen, die das Programm öffnet (bis 16); Voraussetzung für Doppelklick in Files und Files.Handle.openDocument.
takes = png, jpgDokumenttypen, die das Programm nur per Ziehen auf sein Fenster annimmt; Files bietet es dafür nie zum Doppelklick an (Ask, 14.11.2026).
Start & Anzeige
dock = no neuNie im Dock zeigen, auch nicht während es läuft (der Datei-Dialog chooser).
start = demand | updateNicht beim Booten starten, nur auf Anfrage (bzw. beim ersten Start einer neuen Systemkopie).
helper = videoDient nur einem anderen Programm; wird in Listen nicht angeboten.
title / category / iconAnzeigename, Gruppe (system, productivity, media, robot, tools) und SVG-Symbol 24 × 24.
Speicher
memory = 512Heap-Grenze in MiB (16 … 2048, Standard 256); mit der Zeile auch eine Garantie.
stack = 4096Stapelgröße in KiB (64 … 8192).
Echtzeit & Daten
realtime = 1000 200 stopEchtzeit-Vertrag: Periode und Budget in µs, Verhalten bei Fristverletzung (log, stop, restart, stop-actuators).
record = samples 64 5 3600 [flight]Eine Messreihe ohne Systemaufrufe (Recorder); flight = Flugschreiber.
publish = detectionsEine Veröffentlichung, die andere ohne Systemaufrufe lesen (Erkennungs- oder Arm-Ring).
subscribe = camera.detectionsBis zu zwei Veröffentlichungen anderer Programme, beim Start nur lesbar eingeblendet.
Netz
connects = api.anthropic.comDie einzigen Hosts, die das Programm erreichen darf.
listens = 443, 80TCP-Ports zum Lauschen (mit network.incoming, bis 8).

Profileuses-…Profile: welche Bibliotheken mitgebaut werden

AufrufWas er tutShape-Aufruf · Zeitbudget
Profile (Dateien uses-…)
(keine Datei)System, Files, Channel, Net, Apps, Settings, TextLine, WallClock, FileType, Maths – Echtzeit-tauglich, ohne Heap.
uses-heapArrays, Strings, Klassen; dazu die Ton-Bibliothek (WAV, FLAC, Pegel, Stimmerkennung).
uses-uiSurface, Canvas, Views, Keyboard, InputField, UITheme, Chart, ScrollBar.
uses-imagePicture, PNG, JPEG, GIF, WebP, BMP, TIFF, PDF schreiben/lesen, Matroska (braucht uses-heap).
uses-archiveZIP lesen/schreiben mit WinZip AES-256, Deflate (braucht uses-heap).
uses-tlsTLS 1.3 (SecureConnection), DNS über HTTPS, Krypto, Vertrauensanker.
uses-aiEine Cloud-KI über deren API (Typ Claude; Schlüssel in Settings › Privatsphäre) – braucht uses-tls und uses-heap.
uses-video / uses-opusVP9-Decoder / Opus-Decoder (braucht uses-heap und uses-image).
uses-svg / uses-web / uses-sqlSVG-Renderer; Browser-Code; SQL-Übersetzer für Datenbanken (nur lesend).
uses-vision / uses-inferAprilTag, Farbflecken, Bewegung / int8-Inferenz (Detektoren).
uses-qr / uses-httpserverQR-Code-Encoder / HTTP/1.1-Server-Bausteine.
uses-reflex / uses-reflexrtReflex-Compiler und -Maschine (Develop) / Echtzeit-Laufzeit.
Beispiel: Manifest eines Programms mit Fenster, eigenen Dateien und Datei-Dialog (apps/reader, apps/dialogcheck)
# Reader: shows PDF documents.
name = reader
id = de.softrobots.reader
title = Reader
category = productivity
icon = icon.svg
capabilities = system.log, ui.surface
kind = system
opens = pdf
start = demand
memory = 768
# Programmordner daneben: uses-heap, uses-image, uses-svg, uses-ui

system · Information, Zeit, Protokoll, Echtzeit, Text

Information über das System, Zeit und Zufall stehen jedem Programm offen; das Protokoll braucht system.log, Prozessoren und Verbrauch system.status. Strom, Uhr stellen, Protokoll lesen und Geheimnisse setzen sind Rechte der Systemprogramme.

Ein Echtzeit-Programm schreibt realtime = <Periode µs> <Budget µs> [log|stop|restart|stop-actuators] ins Manifest. Der Kern lässt es nur zu, wenn das Budget auf dem Echtzeit-Kern Platz hat, und startet jede Periode pünktlich. Echtzeit-Programme haben keinen Heap, keine Dateien und keine Settings (keine uses-heap-Datei); sie rufen System.waitForNextPeriod() einmal pro Periode. Daten tauschen sie ohne Systemaufruf: Abos (subscribe =), Arm-Ring, Kanäle mit receivePolling und Messreihen (Recorder, record = …).

Ohne Heap braucht es feste Bausteine: TextLine ist eine Zeile fester Größe (160 Bytes), WallClock rechnet Kalenderzeiten (Berlin), Maths (die Mathematik-Bibliothek für jedes Profil) steht jetzt unter Bibliotheken › maths.

Teile nur für Systemprogramme: System-API › system.

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
system.logZeilen ins Systemprotokoll schreiben.≤ 5 µssystem.log0x0002_0003
system.statusSystemzustand lesen: Belegung, Prozessoren, Verbrauch aller Programme.≤ 100 µsprograms.usage0x0006_000E

SystemaufrufesystemModul 0x0002 · Der Roboter selbst: Info, Zeit, Protokoll, Strom, Zufall, Prozessoren, Worker-Threads; Ereignisse start/stop.

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
system.infoInfoRequest → SystemInfokeins≤ 5 µs0x0002_0001
system.nowNowRequest → Nowkeins≤ 1 µs0x0002_0002
system.logLogLine → Donesystem.log≤ 5 µs0x0002_0003
system.processorTimesInfoRequest → ProcessorTimessystem.status≤ 5 µs0x0002_0006
system.randomRandomRequest → RandomByteskeins≤ 5 µs0x0002_0009
system.processorProcessorQuery → Processorsystem.status≤ 5 µs0x0002_000B
system.bootTimesInfoRequest → BootTimessystem.status≤ 5 µs0x0002_000C
system.realtimeRealtimeQuery → RealtimeStatskeins≤ 2 µs0x0002_000D
system.startWorkerWorkerStart → WorkerStartedkeins≤ 1 ms0x0002_000E
system.start eventStartedReflex-EreignisEreignis0x0002_0007
system.stop eventStoppingReflex-EreignisEreignis0x0002_0008

SystemaufrufeSystemCallprimitive Systemaufrufe (enum SystemCall)

NameWas er tutRechtNummer
exitProgramm beendenkeins0
yieldRechenzeit abgebenkeins1
sleepSchlafen (ns)keins2
waitAuf Fenster/Dienst wartenkeins3
periodWaitEchtzeit: nächste Periodekeins4
memoryGrowHeap vergrößernkeins5
workerWakeWorker-Thread weckenkeins6
workerExitWorker-Thread beendenkeins7
channelNotifyKanal: Gegenseite weckenchannels.ipc8
channelWaitKanal: wartenchannels.ipc9
surfaceNotifyFenster: Dienst weckenkeins11
shapeCallShape-Aufruf: alle Module untenkeins13

SystemaufrufecoreModul 0x0001 · Gemeinsame Shapes aller Module: Problem, Punkt, Drehung, Pose, Pixelrechteck.

Keine Aufrufe – nur gemeinsame Shapes.

SwiftSystemInformation, Protokoll, Zeit, Ablauf, Zufall

AufrufWas er tutShape-Aufruf · Zeitbudget
Information
System.info() -> SystemStatus?apiVersion, version, deviceName, uptime, wallClock, cpus, realtimeCPU, memoryTotal/Free, screenWidth/Height, emergencyStopped, dataAvailable, dataProtected, memoryLow, deviceKey, arm, address, hasAES neu (AES/PMULL-Befehle), versionShown neu („0.15.0 · Build N“; version ist „0.15.0+N“) …≤ 5 µssystem.info0x0002_0001
Beispiel
if let info = System.info() { info.arm.forEachByte { if count < 16 { id[count] = $0; count += 1 } } }
aus apps/actuators (gekürzt)
System.processor(_ index: Int) -> ProcessorInfo?Kern, Takt, Temperatur, Name (system.status).≤ 5 µssystem.processor0x0002_000B
Beispiel
var index = 0
while let cpu = System.processor(index) { var name = TextLine(); cpu.appendName(to: &name); index += 1 }
Muster (kurz, nicht aus einem Programm kopiert)
System.cpuStatus() -> (cpus: Int, now: UInt64, idle: InlineArray<8, UInt64>)?Leerlaufzeit je CPU (system.status).≤ 5 µssystem.processorTimes0x0002_0006
Beispiel
if let status = System.cpuStatus() { /* status.idle[cpu], status.now */ }
aus apps/activity (gekürzt)
System.bootMeasurements() -> InlineArray<20, UInt64?>?Messungen des Kerns von diesem Start (Benchmark).≤ 5 µssystem.bootTimes0x0002_000C
Protokoll
System.log(_ text: StaticString) -> Bool / .log(_ line: TextLine) -> BoolEine Zeile ins Systemprotokoll (höchstens 160 Bytes; system.log).≤ 5 µssystem.log0x0002_0003
Beispiel
System.log("reader: no window")
aus apps/reader (gekürzt)
System.log(_ text: UnsafeRawBufferPointer, level: LogLevel) -> BoolMit Stufe .debug/.info/.warning/.error (Activity › Log).≤ 5 µssystem.log0x0002_0003
Zeit
System.time: UInt64 / System.now() -> Nowns seit Start / Wanduhr (ns seit 1970), seit Start, Zeitzone.≤ 1 µssystem.now0x0002_0002
Beispiel
static var wall: Int64 { System.now().wall }
aus apps/develop (gekürzt)
System.wallClock: UInt64Millisekunden seit 1970 (0 solange unbekannt).≤ 1 µssystem.now0x0002_0002
Ablauf
System.sleep(nanoseconds: UInt64)Schlafen.sleep (Systemaufruf 2)
Beispiel
System.sleep(nanoseconds: 10_000_000)
aus apps/dialogcheck (gekürzt)
System.yield()Rechenzeit abgeben.yield (Systemaufruf 1)
System.exit(_ code: UInt64) -> NeverProgramm beenden.exit (Systemaufruf 0)
Beispiel
case .close: System.exit(0)
aus sdk-apps/greeter (gekürzt)
Zufall
System.random<let n: Int>(_ buffer: inout InlineArray<n, UInt8>) -> BoolZufallsbytes aus dem Generator des Kerns (Schlüssel, Nonces).≤ 5 µssystem.random0x0002_0009
Beispiel
var key = InlineArray<32, UInt8>(repeating: 0)
guard System.random(&key) else { return }
Muster (kurz, nicht aus einem Programm kopiert)

SwiftSystemEchtzeit

AufrufWas er tutShape-Aufruf · Zeitbudget
Periode
System.waitForNextPeriod()Die Arbeit dieser Periode ist getan; kehrt zum Beginn der nächsten zurück.periodWait (Systemaufruf 4)
Beispiel
System.waitForNextPeriod()   // am Ende jeder Periode
aus apps/control (gekürzt)
System.time: UInt64Nanosekunden seit dem Start.≤ 1 µssystem.now0x0002_0002
Statistik
System.realtimeStats(restartWorst: Bool = false) -> RealtimeStats?Perioden, verpasste Fristen, schlechteste und mittlere Startlatenz (Sekunden), Periode; nil für normale Programme.≤ 2 µssystem.realtime0x0002_000D
Beispiel
if System.time >= nextReport, let stats = System.realtimeStats(restartWorst: true) { /* stats.missed, stats.worstLatency */ }
aus apps/control (gekürzt)

SwiftRecorderMessreihen ohne Systemaufruf

AufrufWas er tutShape-Aufruf · Zeitbudget
Aufzeichnen
Recorder.attach() -> Recorder?staticDie Aufnahme des Programms; nil ohne record =-Zeile.
Beispiel
guard let recorder = Recorder.attach() else { return }   // braucht record = … im Manifest
Muster (kurz, nicht aus einem Programm kopiert)
Recorder.push(time: UInt64, _ data: Span<UInt8>) -> BoolEinen Satz anhängen (Zeit + bis recordSize − 8 Bytes); false wenn der Ring voll war (gezählt).
Beispiel
recorder.push(time: System.time, sample.span)
aus apps/rtrecord (gekürzt)
Zustand
Recorder.dropped / .recordSize / .flightVerworfene Sätze, Satzgröße, Flugschreiber (überschreibt das Älteste, gesichert nur bei Not-Halt oder Absturz).

SwiftTextLineEine Zeile fester Größe

AufrufWas er tutShape-Aufruf · Zeitbudget
Anlegen
TextLine() / TextLine(_ text: StaticString)Leere bzw. vorbelegte Zeile.
Anhängen
TextLine.append(_ text: StaticString) / .append(_ other: TextLine) / .append(byte: UInt8)Anhängen.
TextLine.append(decimal value: UInt64) / .append(hex value: UInt64, minimumDigits: Int = 1)Zahlen anhängen.
Beispiel
var line = TextLine("ipcping: ")
line.append(decimal: rounds)
line.append(" round trips")
aus apps/ipcping (gekürzt)
Lesen
TextLine.count / .subscript(index:) / .forEachByte(_:) / .capacityLesen.

SwiftWallClock · CivilTimeKalenderzeit

AufrufWas er tutShape-Aufruf · Zeitbudget
Umrechnen
WallClock.civil(unixMilliseconds: Int64) -> CivilTimems seit 1970 → Jahr, Monat, Tag, Stunde, Minute, Sekunde, Millisekunde.
Beispiel
let local = WallClock.civil(unixMilliseconds: milliseconds + WallClock.berlinOffset(unixSeconds: milliseconds / 1000) * 1000)
aus apps/files (gekürzt)
WallClock.berlinOffset(unixSeconds: Int64) -> Int64Versatz der Berliner Zeit (mit Sommerzeit).
WallClock.unixSeconds(_ time: CivilTime) -> Int64 / .days(year:month:day:)Rückrechnung.
Ausgeben
WallClock.appendDate(_ time: CivilTime, to line: inout TextLine) / .appendTime(_:to:)"2026-11-10" / "14:23:05" anhängen.
Beispiel
WallClock.appendDate(local, to: &line)
aus apps/files (gekürzt)
Beispiel: Systeminformation, Einstellungen, ein Programm starten (apps/apicheck)
guard let info = System.info() else { fail("no system information"); return }
guard info.apiVersion == 1, info.version.count > 0, info.cpus >= 1 else { fail("system information looks wrong"); return }

let callcost: StaticString = "callcost"
_ = callcost.withUTF8Buffer { Programs.launch(Span(_unsafeElements: $0)) }
Beispiel: 1-kHz-Regelschleife mit Echtzeit-Vertrag (apps/control)
// manifest: realtime = 1000 100      (Periode 1000 µs, Budget 100 µs; keine uses-heap-Datei)
@c(app_main)
func appMain() {
    var position: Int64 = 0, target: Int64 = 10_000, integral: Int64 = 0, previousError: Int64 = 0
    var nextReport = System.time + 5_000_000_000
    while true {
        let error = target - position
        integral += error
        let derivative = error - previousError
        previousError = error
        position += (error * 8 + integral / 64 + derivative * 2) / 256
        if System.time >= nextReport, let stats = System.realtimeStats(restartWorst: true) {
            nextReport += 5_000_000_000
            var line = TextLine("control: ")
            line.append(decimal: stats.missed)
            line.append(" missed, worst ")
            line.append(decimal: UInt64(stats.worstLatency * 1e9))
            line.append(" ns")
            System.log(line)
        }
        System.waitForNextPeriod()
    }
}
Beispiel: Messwerte aufzeichnen
// manifest: record = samples 64 5 3600     (Name, Satzgröße, Sekunden im Ring, Sekunden auf Platte)
guard let recorder = Recorder.attach() else { return }
var record = InlineArray<56, UInt8>(repeating: 0)
// ... record füllen
_ = recorder.push(time: System.time, record.span)
Beispiel: Eine Zeile mit Datum bauen
var line = TextLine("Stand ")
let time = WallClock.civil(unixMilliseconds: Int64(System.wallClock))
WallClock.appendDate(time, to: &line)
line.append(" ")
WallClock.appendTime(time, to: &line)
line.append(", Winkel ")
line.append(decimal: UInt64(Maths.degrees(Maths.atan2(1, 1))))
System.log(line)
Alle 97 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
CivilTime.var hour: Int, minute: Int, second: Int
CivilTime.var millisecond
CivilTime.var year: Int, month: Int, day: Int
ProcessorInfo.func appendName(to line: inout TextLine)
ProcessorInfo.var isEfficiency: Bool
ProcessorInfo.var isPerformance: Bool
ProcessorInfo.var kind
ProcessorInfo.var megahertz
ProcessorInfo.var midr: UInt64
ProcessorInfo.var temperature
Recorder.func push(time: UInt64, _ data: Span<UInt8>) -> Bool
Recorder.let flight: Bool
Recorder.let recordSize: Int
Recorder.static func attach() -> Recorder?
Recorder.var dropped: UInt32
ShapeCall.func element<E: ShapeValue>(_ list: ShapeSlice, _ index: Int, as: E.Type) -> E
ShapeCall.func resultBytes(_ slice: ShapeSlice, _ body: (UnsafeRawBufferPointer) -> Void)
ShapeCall.func resultEquals(_ slice: ShapeSlice, _ text: StaticString) -> Bool
ShapeCall.init()
ShapeCall.mutating func bytes(_ source: UnsafeRawBufferPointer) -> ShapeSlice
ShapeCall.mutating func send<Q: ShapeValue, R: ShapeValue>(_ id: UInt32, _ value: Q, as: R.Type) -> ShapeOutcome<R>
ShapeCall.mutating func send<Q: ShapeValue, R: ShapeValue>(_ id: UInt32, _ value: Q, as: R.Type,
ShapeCall.mutating func sendPatched<Q: ShapeValue, R: ShapeValue>(_ id: UInt32, _ value: Q, patchOffset: Int, byte: UInt8,
ShapeCall.mutating func text(_ bytes: StaticString) -> ShapeSlice
System.static func bootMeasurements() -> InlineArray<20, UInt64?>?
System.static func cpuStatus() -> (cpus: Int, now: UInt64, idle: InlineArray<8, UInt64>)?
System.static func exit(_ code: UInt64) -> Never
System.static func info() -> SystemStatus?
System.static func log(_ line: TextLine) -> Bool
System.static func log(_ text: StaticString) -> Bool
System.static func log(_ text: UnsafeRawBufferPointer, level: LogLevel) -> Bool
System.static func now() -> Now
System.static func processor(_ index: Int) -> ProcessorInfo?
System.static func random<let n: Int>(_ buffer: inout InlineArray<n, UInt8>) -> Bool
System.static func realtimeStats(restartWorst: Bool = false) -> RealtimeStats?
System.static func sleep(nanoseconds: UInt64)
System.static func waitForNextPeriod()
System.static func yield()
System.static var time: UInt64
System.static var wallClock: UInt64
SystemStatus.var address: UInt32
SystemStatus.var afterUpdate
SystemStatus.var apiVersion
SystemStatus.var arm
SystemStatus.var bootAnimation
SystemStatus.var connectsRestricted
SystemStatus.var cpus
SystemStatus.var dataAvailable
SystemStatus.var dataProtected
SystemStatus.var deviceKey
SystemStatus.var deviceName
SystemStatus.var emergencyStopped
SystemStatus.var hasAES
SystemStatus.var hasDotProduct
SystemStatus.var hasMatrixMultiply
SystemStatus.var heapPeak: UInt64
SystemStatus.var memoryFree: UInt64
SystemStatus.var memoryGuarantee: UInt64
SystemStatus.var memoryLow
SystemStatus.var memoryTotal: UInt64
SystemStatus.var publishing
SystemStatus.var realtimeCPU
SystemStatus.var recording
SystemStatus.var screenHeight
SystemStatus.var screenWidth
SystemStatus.var subscriptions
SystemStatus.var uptime: UInt64
SystemStatus.var version
SystemStatus.var versionShown: TextLine
SystemStatus.var wallClock: UInt64
TextLine.func forEachByte(_ body: (UInt8) -> Void)
TextLine.init()
TextLine.init(_ text: StaticString)
TextLine.mutating func append(_ other: TextLine)
TextLine.mutating func append(_ text: StaticString)
TextLine.mutating func append(byte: UInt8)
TextLine.mutating func append(decimal value: UInt64)
TextLine.mutating func append(hex value: UInt64, minimumDigits: Int = 1)
TextLine.private(set) var count
TextLine.static let capacity
TextLine.subscript(index: Int) -> UInt8
WallClock.static func appendDate(_ time: CivilTime, to line: inout TextLine)
WallClock.static func appendTime(_ time: CivilTime, to line: inout TextLine)
WallClock.static func berlinOffset(unixSeconds: Int64) -> Int64
WallClock.static func civil(unixMilliseconds: Int64) -> CivilTime
WallClock.static func days(year: Int, month: Int, day: Int) -> Int
WallClock.static func unixSeconds(_ time: CivilTime) -> Int64
enum ShapeOutcome<R: ShapeValue>
enum System
enum SystemCall: UInt64
enum WallClock
struct CivilTime: Equatable
struct ProcessorInfo
struct Recorder
struct ShapeCall
struct SystemStatus
struct TextLine

programs · Das eigene Programm, Einstellungen, andere Programme

Das eigene Programm: das übergebene Dokument, die eigenen Einstellungen, der eigene Verbrauch (mit system.status). Andere Programme starten, stoppen, auflisten, ihre Abstürze lesen oder Programme bauen dürfen nur Systemprogramme (programs.launch, programs.build).

Settings sind kleine, private Einstellungen pro Programm (key = value, höchstens 4 KiB), vom System in DATA gehalten – kein Datei-Recht nötig.

Teile nur für Systemprogramme: System-API › programs.

Rechte

Kein Recht nötig: das eigene Dokument und die eigenen Einstellungen stehen jedem Programm offen; der Verbrauch braucht system.status (Modul system).

SystemaufrufeprogramsModul 0x0006 · Das Programm selbst und die anderen: Dokument, Settings, Geheimnis, Start/Stopp, Listen, Abstürze, Bauen.

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
programs.documentDocumentRequest → HandedDocumentkeins≤ 5 µs0x0006_0001
programs.settingsSettingsRequest → SettingsDatakeins≤ 200 µs0x0006_0002
programs.saveSettingsSettingsData → Donekeins≤ 2 ms0x0006_0003
programs.ownSecretSettingsRequest → SecretDatakeins≤ 2 ms0x0006_0006
programs.usageProgramListQuery → UsageListsystem.status≤ 100 µs0x0006_000E

SwiftProgramsDas übergebene Dokument, Verbrauch

AufrufWas er tutShape-Aufruf · Zeitbudget
Dokument
Programs.document() -> (name: InlineArray<80, UInt8>, length: Int, generation: UInt64)?Das diesem Programm übergebene Dokument; generation ändert sich mit jedem neuen.≤ 5 µsprograms.document0x0006_0001
Beispiel
guard let document = Programs.document(), document.generation != generation else { return false }
aus apps/reader (gekürzt)
Listen
Programs.usage(at index: Int) -> Usage?Verbrauch: CPU-Zeit, Speicher, Heap, Fenster, Datei- und Netzverkehr … (system.status).≤ 100 µsprograms.usage0x0006_000E
Beispiel
while let usage = Programs.usage(at: index) { /* usage.cpuTime, usage.memory, usage.total */ index += 1 }
aus apps/activity (gekürzt)
Programs.Usage.buddyStage: IntBuddys Speicherstufe eines Programms ohne memory =-Zeile: 0 ruhig, 1 schnüffeln, 2 knurren, 3 bellen (1/4, 1/2, 3/4 seiner Grenze).programs.usage

SwiftSettingsEigene Einstellungen (ohne Datei-Recht)

AufrufWas er tutShape-Aufruf · Zeitbudget
Laden
Settings.load() -> Settings?staticDie zuletzt gesicherten Einstellungen (beim ersten Mal leer); nil solange DATA gesperrt ist und für Echtzeit-Programme.≤ 200 µsprograms.settings0x0006_0002
Beispiel
guard var settings = Settings.load() else { fail("settings could not be loaded"); return }
aus apps/apicheck (gekürzt)
Lesen
Settings.value(_ key: StaticString) -> TextLine?Wert eines Schlüssels.
Beispiel
let greeting = settings.value("greeting")   // TextLine?
aus apps/apicheck (gekürzt)
Settings.number(_ key: StaticString) -> Int?Wert als ganze Zahl.
Beispiel
let runs = (settings.number("runs") ?? 0) + 1
aus apps/apicheck (gekürzt)
Setzen
Settings.set(_ key: StaticString, _ value: TextLine) -> BoolSetzt einen Text; false wenn 4 KiB überschritten würden.
Beispiel
settings.set("greeting", TextLine("hello robot"))
aus apps/apicheck (gekürzt)
Settings.set(_ key: StaticString, number: Int) -> BoolSetzt eine Zahl.
Beispiel
settings.set("runs", number: runs)
aus apps/apicheck (gekürzt)
Sichern
Settings.save() -> BoolSchreibt die Einstellungen.≤ 2 msprograms.saveSettings0x0006_0003
Beispiel
guard settings.save() else { fail("settings were not kept"); return }
aus apps/apicheck (gekürzt)
Beispiel: Einstellungen merken (docs/api/README.md)
if var settings = Settings.load() {
    let starts = (settings.number("starts") ?? 0) + 1
    settings.set("starts", number: starts)
    settings.set("greeting", TextLine("hello robot"))
    _ = settings.save()
}
Alle 39 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
Programs.Usage.var buddyStage: Int
Programs.Usage.var capabilities: UInt64
Programs.Usage.var channelWakeUps: UInt64
Programs.Usage.var cpu
Programs.Usage.var cpuTime: UInt64
Programs.Usage.var cushion: UInt64
Programs.Usage.var fileRead: UInt64
Programs.Usage.var fileWritten: UInt64
Programs.Usage.var guarantee: UInt64
Programs.Usage.var heap: UInt64
Programs.Usage.var heapLimit: UInt64
Programs.Usage.var heapPeak: UInt64
Programs.Usage.var kind
Programs.Usage.var memory: UInt64
Programs.Usage.var missed: UInt64
Programs.Usage.var name
Programs.Usage.var nameLength
Programs.Usage.var networkReceived: UInt64
Programs.Usage.var networkSent: UInt64
Programs.Usage.var pagedOut: UInt64
Programs.Usage.var period: UInt64
Programs.Usage.var realtime
Programs.Usage.var slot
Programs.Usage.var started: UInt64
Programs.Usage.var state
Programs.Usage.var systemCalls: UInt64
Programs.Usage.var total: UInt64
Programs.Usage.var windows: UInt64
Programs.static func document() -> (name: InlineArray<80, UInt8>, length: Int, generation: UInt64)?
Programs.static func usage(at index: Int) -> Usage?
Programs.struct Usage
Settings.func number(_ key: StaticString) -> Int?
Settings.func save() -> Bool
Settings.func value(_ key: StaticString) -> TextLine?
Settings.mutating func set(_ key: StaticString, _ value: TextLine) -> Bool
Settings.mutating func set(_ key: StaticString, number: Int) -> Bool
Settings.static func load() -> Settings?
enum Programs
struct Settings

files · Dateien und Ordner

Mit files.own beginnt jeder Pfad im eigenen Ordner /data/<id> – sonst existiert nichts. files.system sieht das ganze Volume (/apps nur lesend, system/…, in der VM mac/…); files.mac ergänzt den eigenen Ordner um den Mac-Ordner. Pfade mit „/“, „.“ und „..“ werden abgelehnt. Änderungen gelten, wenn die Datei geschlossen wird; pro Systemaufruf höchstens 16 KiB. Ein Programm mit opens = … bekommt sein übergebenes Dokument mit Files.Handle.openDocument ohne Datei-Recht, eine im Dialog gewählte Datei mit Files.Handle.open(grant, mode:).

Seit 11.11. heißt die geöffnete Datei Files.Handle (Umbenennungen: Überblick); Files, Files.Handle und FileError stehen in app-api-1.txt. Schnappschüsse und „In Files zeigen“ brauchen Rechte der Systemprogramme.

Teile nur für Systemprogramme: System-API › files.

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
files.ownDateien im eigenen Ordner /data/<id>; sonst existiert nichts.≤ 2 msfiles.open0x0003_0001

SystemaufrufefilesModul 0x0003 · Dateien des Programms, Ordner, Volume und Snapshots.

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
files.openOpenFile → FileOpenedfiles.own oder files.system (+ files.mac für mac/, + system.log.read für crashes/, logs/)≤ 2 ms0x0003_0001
files.readFileRead → FileDatakeins≤ 2 ms0x0003_0002
files.writeFileWrite → FileWrittenkeins≤ 2 ms0x0003_0003
files.closeFileRequest → Donekeins≤ 5 ms0x0003_0004
files.listListFolder → FolderEntriesfiles.own oder files.system (+ files.system für einen Schnappschuss)≤ 2 ms0x0003_0005
files.infoFileQuery → FileInfofiles.own oder files.system (+ files.system für einen Schnappschuss)≤ 200 µs0x0003_0006
files.makeFolderFileQuery → Donefiles.own oder files.system≤ 2 ms0x0003_0007
files.removeFileQuery → Donefiles.own oder files.system≤ 2 ms0x0003_0008
files.renameRename → Donefiles.own oder files.system≤ 2 ms0x0003_0009
files.volumeVolumeQuery → VolumeInfosystem.status oder files.system oder files.own≤ 50 µs0x0003_000B

SwiftFiles.HandleEine geöffnete Datei

AufrufWas er tutShape-Aufruf · Zeitbudget
Öffnen
Files.Handle.open(_ path: Span<UInt8> | StaticString, mode: Mode) -> Result<Files.Handle, FileError>staticÖffnet eine Datei; Modus .read, .replace (anlegen/leeren), .append, .update (lesen und schreiben an jeder Stelle).≤ 2 msfiles.open0x0003_0001
Beispiel
guard case .success(let file) = Files.Handle.open("notes.txt", mode: .read) else { return }
aus sdk-apps/notes (gekürzt)
Files.Handle.openDocument(mode: Mode) -> Result<Files.Handle, FileError>staticÖffnet das von Files übergebene Dokument (siehe Programs.document).≤ 2 msfiles.open0x0003_0001
Beispiel
switch Files.Handle.openDocument(mode: .read) {
case .failure(let error): message = TextLine(error.text)
case .success(let file): read(file)
}
aus apps/reader (gekürzt)
Files.Handle.open(_ grant: FileGrant, mode: Mode) -> Result<Files.Handle, FileError>static neuÖffnet eine im Datei-Dialog gewählte Datei.≤ 2 msfiles.open0x0003_0001
Lesen
Files.Handle.read(into buffer: inout MutableSpan<UInt8>) -> Result<Int, FileError>Liest die nächsten Bytes (höchstens 16 KiB); 0 am Ende.≤ 2 msfiles.read0x0003_0002
Beispiel
var chunk = InlineArray<1024, UInt8>(repeating: 0)
var span = chunk.mutableSpan
guard case .success(let count) = file.read(into: &span), count > 0 else { break }
aus sdk-apps/notes (gekürzt)
Files.Handle.read(into buffer: inout MutableSpan<UInt8>, at offset: UInt64) -> Result<Int, FileError>Liest ab einer beliebigen Stelle.≤ 2 msfiles.read0x0003_0002
Beispiel
guard case .success(let got) = file.read(into: &span, at: 0), got >= 44 else { return }   // WAV-Kopf
aus apps/sound (gekürzt)
Schreiben
Files.Handle.write(_ data: Span<UInt8>) -> FileError?Hängt alle Bytes an (in Stücken zu 16 KiB).≤ 2 msfiles.write0x0003_0003
Beispiel
bytes.withUnsafeBufferPointer { buffer in _ = file.write(Span(_unsafeElements: buffer)) }
aus sdk-apps/notes (gekürzt)
Files.Handle.write(_ data: Span<UInt8>, at offset: UInt64) -> FileError?Schreibt an eine Stelle (höchstens bis zur Größe: keine Löcher).≤ 2 msfiles.write0x0003_0003
Beispiel
_ = pending.withUnsafeBufferPointer { handle.write(Span(_unsafeElements: $0), at: bytes) }
aus apps/sound (gekürzt)
Schließen
Files.Handle.close() -> FileError?Schließt und übernimmt die Änderungen.≤ 5 msfiles.close0x0003_0004
Beispiel
_ = file.close()   // erst jetzt sind die Änderungen übernommen
aus sdk-apps/about (gekürzt)
Konstanten
Files.Handle.chunk = 16384 / .handle: UInt64staticBytes pro Systemaufruf / Nummer der Datei.

SwiftFilesOrdner, Infos und Änderungen über Pfade

AufrufWas er tutShape-Aufruf · Zeitbudget
Ordner
Files.entry(in path: Span<UInt8>, at index: Int, snapshot: UInt64? = nil) -> Result<Entry?, FileError>staticDer index-te Eintrag eines Ordners (optional wie in einem Snapshot); nil nach dem letzten. Index 0 liest neu.≤ 2 msfiles.list0x0003_0005
Beispiel
var index = 0
while case .success(let entry?) = folder.withUnsafeBufferPointer({ Files.entry(in: Span(_unsafeElements: $0), at: index) }) {
    index += 1
}
aus apps/testcamera (gekürzt)
Files.makeDirectory(_ path: Span<UInt8>) -> FileError?staticOrdner anlegen (leerer Pfad: der eigene Ordner).≤ 2 msfiles.makeFolder0x0003_0007
Beispiel
_ = folder.withUTF8Buffer { Files.makeDirectory(Span(_unsafeElements: $0)) }
aus apps/sound (gekürzt)
Files.Entry: isDirectory, size, modified, name, nameLengthEin Ordnereintrag.
Info
Files.info(_ path: Span<UInt8> | StaticString, snapshot: UInt64? = nil) -> Result<(isDirectory: Bool, size: UInt64, modified: UInt64), FileError>staticOrdner?, Größe (Ordner: Gesamtgröße), letzte Änderung.≤ 200 µsfiles.info0x0003_0006
Beispiel
guard case .success(let runs) = Files.info("runs.log") else { return fail("runs.log has no size") }
aus apps/shapecheck (gekürzt)
Files.volume(system: Bool = false) -> InlineArray<5, UInt64>?staticDATA oder Systemvolume: Blockgröße, Blöcke, belegt, Snapshots, Generation.≤ 50 µsfiles.volume0x0003_000B
Beispiel
if let data = Files.volume() { dataUsed = data[2] * data[0]; dataTotal = data[1] * data[0]; snapshots = data[3] }
aus apps/activity (gekürzt)
Ändern
Files.remove(_ path: Span<UInt8> | StaticString) -> FileError?staticDatei oder leeren Ordner löschen.≤ 2 msfiles.remove0x0003_0008
Beispiel
if Files.remove("shapecheck-moved.txt") != nil { failed("remove") }
aus apps/shapecheck (gekürzt)
Files.rename(_ path: Span<UInt8>, to newPath: Span<UInt8>, replacing: Bool) -> FileError?staticVerschieben/umbenennen; mit replacing atomar über eine vorhandene Datei.≤ 2 msfiles.rename0x0003_0009
Beispiel
let renamed = old.withUTF8Buffer { o in new.withUTF8Buffer { n in Files.rename(Span(_unsafeElements: o), to: Span(_unsafeElements: n)) } }
aus apps/sharecheck (gekürzt)
Files.replace(_ path: Span<UInt8>, with data: Span<UInt8>) -> FileError?staticGanzen Inhalt atomar ersetzen (erst .new, dann umbenennen).≤ 2 msfiles.open + files.rename0x0003_0001
Beispiel
_ = path.withUnsafeBufferPointer { p in bytes.withUnsafeBufferPointer { b in Files.replace(Span(_unsafeElements: p), with: Span(_unsafeElements: b)) } }
aus apps/settings (gekürzt)

SwiftFileErrorFehler

AufrufWas er tutShape-Aufruf · Zeitbudget
FileError
FileError: refused, badArgument, notFound, exists, notADirectory, notEmpty, noSpace, ioError, isADirectory, tooManyOpen, …Warum eine Dateioperation scheiterte; locked = DATA noch versiegelt, wrongContent = Inhalt passt nicht zur Endung.
FileError.text: StaticString / FileError.from(_ result: UInt64) -> FileError?Kurzer englischer Satz für Meldungen / Fehler aus einem Rückgabewert.

SwiftFileTypeDokumenttypen

AufrufWas er tutShape-Aufruf · Zeitbudget
Dokumenttypen
FileType.of(_ name: Span<UInt8>) -> FileTypestaticTyp nach der Endung.
FileType.label: StaticString / .isText / .isDatabaseAnzeigename und Art.
FileType.accepts(_ prefix: Span<UInt8>, complete: Bool) -> BoolPasst der Inhaltsanfang zum Typ?
FileType.extensionRange / .validUTF8 / .namesSVGElement / .equal / .maxExtensionstaticHilfen zu Endungen und Inhalt.
Beispiel: Eigene Datei lesen und schreiben (sdk-apps/notes)
// manifest: capabilities = system.log, ui.surface, files.own   (+ uses-heap)
guard case .success(let file) = Files.Handle.open("notes.txt", mode: .read) else { return }
var bytes: [UInt8] = []
var chunk = InlineArray<1024, UInt8>(repeating: 0)
while true {
    var span = chunk.mutableSpan
    guard case .success(let count) = file.read(into: &span), count > 0 else { break }
    for index in 0..<count { bytes.append(chunk[index]) }
}
file.close()

guard case .success(let out) = Files.Handle.open("notes.txt", mode: .replace) else { return }
bytes.withUnsafeBufferPointer { buffer in _ = out.write(Span(_unsafeElements: buffer)) }
out.close()
Beispiel: Einen Ordner auflisten (apps/testcamera)
var index = 0
while case .success(let entry?) = folder.withUnsafeBufferPointer({ Files.entry(in: Span(_unsafeElements: $0), at: index) }) {
    // entry.name[0..<entry.nameLength], entry.isDirectory, entry.size, entry.modified
    index += 1
}
Beispiel: Das übergebene Dokument öffnen (apps/reader)
// manifest: opens = pdf   – kein files-Recht nötig
guard let document = Programs.document(), document.generation != generation else { return false }
generation = document.generation
switch Files.Handle.openDocument(mode: .read) {
case .failure(let error): message = TextLine(error.text)
case .success(let file):  // ... lesen, file.close()
}
Alle 44 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
FileError.static func from(_ result: UInt64) -> FileError?
FileError.var text: StaticString
FileType.func accepts(_ prefix: Span<UInt8>, complete: Bool) -> Bool
FileType.static func equal(_ name: Span<UInt8>, _ start: Int, _ end: Int, _ word: StaticString) -> Bool
FileType.static func extensionRange(_ name: Span<UInt8>) -> (start: Int, end: Int)?
FileType.static func namesSVGElement(_ bytes: Span<UInt8>) -> Bool
FileType.static func of(_ name: Span<UInt8>) -> FileType
FileType.static func validUTF8(_ bytes: Span<UInt8>, complete: Bool) -> Bool
FileType.static let maxExtension
FileType.var isDatabase: Bool
FileType.var isText: Bool
FileType.var label: StaticString
Files.Entry.var isDirectory
Files.Entry.var modified: UInt64
Files.Entry.var name
Files.Entry.var nameLength
Files.Entry.var size: UInt64
Files.Handle.enum Mode: UInt64
Files.Handle.func close() -> FileError?
Files.Handle.func read(into buffer: inout MutableSpan<UInt8>) -> Result<Int, FileError>
Files.Handle.func read(into buffer: inout MutableSpan<UInt8>, at offset: UInt64) -> Result<Int, FileError>
Files.Handle.func write(_ data: Span<UInt8>) -> FileError?
Files.Handle.func write(_ data: Span<UInt8>, at offset: UInt64) -> FileError?
Files.Handle.let handle: UInt64
Files.Handle.static func open(_ grant: FileGrant, mode: Mode) -> Result<Files.Handle, FileError>
Files.Handle.static func open(_ path: Span<UInt8>, mode: Mode) -> Result<Files.Handle, FileError>
Files.Handle.static func open(_ path: StaticString, mode: Mode) -> Result<Files.Handle, FileError>
Files.Handle.static func openDocument(mode: Mode) -> Result<Files.Handle, FileError>
Files.Handle.static let chunk
Files.static func entry(in path: Span<UInt8>, at index: Int, snapshot: UInt64? = nil) -> Result<Entry?, FileError>
Files.static func info(_ path: Span<UInt8>, snapshot: UInt64? = nil) -> Result<(isDirectory: Bool, size: UInt64, modified: UInt64), FileError>
Files.static func info(_ path: StaticString) -> Result<(isDirectory: Bool, size: UInt64, modified: UInt64), FileError>
Files.static func makeDirectory(_ path: Span<UInt8>) -> FileError?
Files.static func remove(_ path: Span<UInt8>) -> FileError?
Files.static func remove(_ path: StaticString) -> FileError?
Files.static func rename(_ path: Span<UInt8>, to newPath: Span<UInt8>) -> FileError?
Files.static func rename(_ path: Span<UInt8>, to newPath: Span<UInt8>, replacing: Bool) -> FileError?
Files.static func replace(_ path: Span<UInt8>, with data: Span<UInt8>) -> FileError?
Files.static func volume(system: Bool = false) -> InlineArray<5, UInt64>?
Files.struct Entry
Files.struct Handle
enum FileError: UInt64, Error
enum FileType: UInt8
enum Files

database · SOFTrobotsDB

Tabellen mit typisierten Feldern, gehalten und geprüft vom Kern (Modul database). Ein Programm beschreibt seine Tabellen als gespeicherte Shapes in data.shape; shapec --database erzeugt daraus Swift-Code (openDatabase, je Tabelle ein Typ mit insert, update, delete, set…, row und den Feldern). Regeln wie unique, Bereiche und Verweise prüft der Kern bei jedem Schreiben; ein Schreibsatz gilt ganz oder gar nicht. Kein Heap: Schreibsätze, Abfragen und Seiten halten ihre Bytes inline (als globale Variablen anlegen). Die eigenen Datenbanken liegen im eigenen Ordner (files.own); fremde schreiben nur mit database.edit.

Seit 11.11. stehen Database, Database.Write, Database.Query und Database.Page in app-api-1.txt (Umbenennungen: Überblick). Der aus data.shape erzeugte Code gehört dem Programm (eigener Abschnitt unten).

Teile nur für Systemprogramme: System-API › database.

Rechte

Kein eigenes Recht: die eigenen Datenbanken liegen im eigenen Ordner und brauchen files.own (Modul files).

SystemaufrufedatabaseModul 0x0004 · SOFTrobotsDB: Datenbanken öffnen, schreiben, abfragen, Messreihen lesen.

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
database.openOpenDatabase → DatabaseOpenedfiles.own oder files.system (+ database.edit, um fremde zu schreiben)≤ 2 ms0x0004_0001
database.writeTableWrite → Writtenfiles.own oder files.system≤ 1 ms0x0004_0002
database.queryTableQuery → TablePagefiles.own oder files.system≤ 5 ms0x0004_0003
database.describeDatabaseRequest → Descriptionfiles.own oder files.system≤ 1 ms0x0004_0004
database.closeDatabaseRequest → Donefiles.own oder files.system≤ 50 µs0x0004_0005
database.readSeriesSeriesRead → SeriesRecordsfiles.own oder files.system≤ 5 ms0x0004_0006

SwiftDatabaseöffnen & schließen

AufrufWas er tutShape-Aufruf · Zeitbudget
Öffnen & schließen
Database.open(_ path: StaticString, schema: Span<UInt8>) -> Result<Database, DatabaseError>staticDasselbe mit einem kompilierten Schema.≤ 2 msdatabase.open0x0004_0001
Database.open(_ path: Span<UInt8>) -> Result<Database, DatabaseError>staticÖffnet, wie sie ist (Werkzeuge wie Konsole und Database).≤ 2 msdatabase.open0x0004_0001
Beispiel
guard case .success(let database) = path.withSpan({ Database.open($0) }) else { return false }
aus apps/database (gekürzt)
Database.close()Schließen.≤ 50 µsdatabase.close0x0004_0005
Beispiel
robot.close()
aus apps/dbcheck (gekürzt)

SwiftDatabase · Database.Writeschreiben: ein Schreibsatz, alles oder nichts

AufrufWas er tutShape-Aufruf · Zeitbudget
Schreiben
Database.write<let capacity: Int>(_ set: inout Database.Write<capacity>, soon: Bool = false) -> Result<Int, DatabaseError>Wendet einen Schreibsatz an (alles oder nichts); gibt die Zahl eingefügter Zeilen. soon: kehrt sofort zurück, auf der Platte binnen 10 ms.≤ 1 msdatabase.write0x0004_0002
Beispiel
Joints.update(&set, id: 7)
Joints.setAngle(&set, 12_345)
guard case .success = robot.write(&set) else { return fail("updating joint 7 failed") }
aus apps/dbcheck (gekürzt)
Satz anlegen
Database.Write.init() / .clear() / .isEmptyLeerer Satz.
Operationen
Database.Write.insert(_ table: StaticString, id: UInt64 = 0) / .update(_:id:) / .delete(_:id:)Operation beginnen (der erzeugte Code ruft das für dich).
Database.Write.set(_ field: Int, bytes: | bool: | int:size: | unsigned:size: | float: | double: | text:) / .setNull(_:)Feldwerte der aktuellen Operation.
Ergebnis
Database.Write.insertedIDs / .insertedCountids der eingefügten Zeilen.

SwiftDatabase.Query · Database.Pageabfragen: Abfrage, Bedingungen, Ergebnisseite

AufrufWas er tutShape-Aufruf · Zeitbudget
Abfragen
Database.next(_ query: inout Database.Query<q>, into page: inout Database.Page<output, cursor>) -> BoolFührt eine Abfrage aus bzw. holt die nächste Seite; false wenn fertig oder Fehler (page.error).≤ 5 msdatabase.query0x0004_0003
Beispiel
page.reset()
while robot.next(&query, into: &page) || page.rowCount > 0 {
    for row in 0..<page.rowCount { let joint = Joints.row(&page, row); _ = joint.angle }
    if page.rowCount == 0 { break }
}
aus apps/dbcheck (gekürzt)
Database.next(query: Span<UInt8>, aggregate: Bool, grouped: Bool, into page: …) -> BoolDasselbe für eine Abfrage aus SQL.translate (uses-sql).≤ 5 msdatabase.query0x0004_0003
Database.firstValue<R>(query: Span<UInt8>, _ body: (Span<UInt8>?) -> R) -> RErster Wert einer übersetzten Abfrage.≤ 5 msdatabase.query0x0004_0003
Tabelle
Database.Query.init(_ table: StaticString)Abfrage auf einer Tabelle.
Beispiel
query = Database.Query(Joints.table)
aus apps/dbcheck (gekürzt)
Filtern
Database.Query.where(_ condition: Condition) / .whereAny(_:_:_:_:)Bedingung (UND) / bis zu vier ODER-Bedingungen.
Beispiel
query.where(Joints.angle >= -10_000)
query.where(Joints.angle < 10_000)
aus apps/dbcheck (gekürzt)
Sortieren & begrenzen
Database.Query.sorted(by field: Int, descending: Bool = false) / .sorted(by:via:descending:)Sortieren (auch über einen Verweis, Join).
Beispiel
query.sorted(by: Joints.angle.index, descending: true)
aus apps/dbcheck (gekürzt)
Database.Query.limit(_ rows: Int) / .select(_ field: Int)Höchstens n Zeilen / nur bestimmte Felder.
Beispiel
query.limit(10)
aus apps/dbcheck (gekürzt)
Aggregate
Database.Query.count(groupedBy:) / .sum / .minimum / .maximum / .average (_ field: Int, groupedBy: Int? = nil)Aggregate, optional gruppiert.
Beispiel
query.count(groupedBy: Joints.status.index)
// je Gruppe: page.aggregate(row).rows
aus apps/dbcheck (gekürzt)
Felder & Bedingungen
NumberField: == != < <= > >= Int64, .isNull, .isNotNull, .via(_ ref:)Bedingungen auf Zahlenfeldern; via = Feld der verwiesenen Tabelle (Join, höchstens zwei Verweise).
Beispiel
query.where(Joints.status.via(Moves.joint) == 1)   // Join über den Verweis
aus apps/dbcheck (gekürzt)
FloatField: == != < <= > >= DoubleBedingungen auf Gleitkommafeldern.
TextField: == StaticString, equals, startsWith, contains, before, afterBedingungen auf Textfeldern.
Seite
Database.Page.init() / .reset()Seite anlegen / für eine neue Abfrage leeren.
Database.Page.rowCount, .error, .plan, .indexZeilen, Fehler, gewählter Plan (Index, Bereich …).
Werte lesen
Database.Page.id(_ row: Int) / .number(_:_:signed:) / .float / .double / .text / .withBytes / .isNull / .valueWerte einer Zeile lesen.
Database.Page.aggregate(_ row: Int) -> (rows: UInt64, value: Int64?) / .groupNumber / .withGroupBytesErgebnis eines Aggregats bzw. einer Gruppe.
Beispiel
for row in 0..<page.rowCount { total += page.aggregate(row).rows }
aus apps/dbcheck (gekürzt)

SwiftDatabase · Series · DatabaseErrorbeschreiben, Messreihen, Fehler

AufrufWas er tutShape-Aufruf · Zeitbudget
Beschreibung
Database.describe(into buffer: inout MutableSpan<UInt8>) -> Result<Int, DatabaseError>Tabellen, Felder und Indizes.≤ 1 msdatabase.describe0x0004_0004
Messreihen
Series.info(_ path: Span<UInt8>) -> Result<Info, FileError>Was eine Messreihe hält: Satzgröße, Sätze, erste/letzte Zeit.≤ 5 msdatabase.readSeries0x0004_0006
Series.read(_ path: Span<UInt8>, from: UInt64, to: UInt64, …)Sätze eines Zeitbereichs (Flugschreiber, Recorder).≤ 5 msdatabase.readSeries0x0004_0006
Fehler
DatabaseError: .system(FileError), .rule(DatabaseRule, operation:, field:)Systemfehler oder verletzte Regel (duplicate, outOfRange, badReference …).
Beispiel
guard case .failure(.rule(.duplicate, operation: 0, field: 1)) = robot.write(&set) else { return fail("a duplicate name was accepted") }
aus apps/dbcheck (gekürzt)

SwiftTabellen aus deiner data.shapevom Werkzeug je Programm erzeugt, nicht in app-api-1.txt

Ein Programm beschreibt seine Tabellen als gespeicherte Shapes in data.shape. Beim Bauen erzeugt shapec --database daraus Swift-Code, der nur in diesem Programm existiert: das kompilierte Schema, openDatabase(_:) und je Tabelle einen Typ <Table> mit typisierten Feldern. Dieser Code ruft nur die Deklarationen oben (Database.open(_:schema:), Database.Write, Database.Page); er gehört zum Programm, nicht zur App-API, und steht deshalb in keiner der beiden Listen. Die Namen unten in spitzen Klammern hängen von deiner data.shape ab (Beispiel apps/dbcheck: Tabellen Joints und Moves).

AufrufWas er tutShape-Aufruf · Zeitbudget
Öffnen
openDatabase(_ path: StaticString) -> Result<Database, DatabaseError>Vom Generator erzeugt: öffnet/legt an und gleicht die Tabellen ans Schema an (Felder hinzu, umbenannt, weg – ohne Zeilen umzuschreiben).≤ 2 msdatabase.open0x0004_0001
Beispiel
guard case .success(let robot) = openDatabase("robot.db") else { return fail("cannot open robot.db") }
aus apps/dbcheck (gekürzt)
Je Tabelle
dataSchema: InlineArray<n, UInt8>Das kompilierte Schema deiner Tabellen; openDatabase gibt es an Database.open(_:schema:) weiter.
<Table>.table: StaticStringDer Tabellenname für Database.Query(<Table>.table). <Table> ist der Name aus stored as … mit großem Anfang (joints → Joints).
<Table>.<field>: NumberField | FloatField | TextFieldJe Feld eine Konstante für Bedingungen und Sortieren: Joints.angle > 90_000, Joints.angle.index.
<Table>.insert(_ set: inout Database.Write<n>, <required fields>)Neue Zeile mit allen Pflichtfeldern (ohne Standardwert) als Parameter; die übrigen gleich danach mit set….
<Table>.update(_ set: inout Database.Write<n>, id: UInt64) / <Table>.delete(_:id:)Zeile id ändern (Felder danach mit set…) bzw. löschen.
<Table>.set<Field>(_ set: inout Database.Write<n>, _ value:) / <Table>.clear<Field>(_:)Ein Feld der aktuellen Operation setzen; clear… nur für optionale Felder (setzt null).
<Table>.Row / <Table>.row(_ page: inout Database.Page<o, c>, _ row: Int) -> RowEine Zeile einer Ergebnisseite mit typisierten Feldern (Abfragen ohne select); Aufzählungen kommen als eigener Typ.
Beispiel: Tabellen beschreiben (apps/dbcheck/data.shape)
enum JointStatus { ok @0, warning @1, fault @2 }

shape Joint stored as joints {
    name: Text(32) unique
    angle: Int32 in -180000 ... 180000
    current: Float32?
    status: JointStatus = .ok
    index status, angle
    index angle
}

shape Move stored as moves {
    joint: Joint
    at: Time
    target: Int32
}
Beispiel: Schreiben, Regeln, Abfrage über Index, Gruppen (apps/dbcheck)
nonisolated(unsafe) var set = Database.Write<65536>()
nonisolated(unsafe) var query = Database.Query<512>(Joints.table)
nonisolated(unsafe) var page = Database.Page<16384, 1024>()

guard case .success(let robot) = openDatabase("robot.db") else { return fail("cannot open robot.db") }

Joints.insert(&set, name: name.span.extracting(0..<length), angle: 45_000)
Joints.setStatus(&set, .warning)
guard case .success(1) = robot.write(&set) else { return fail("insert failed") }

// Regeln prüft der Kern:
guard case .failure(.rule(.duplicate, operation: 0, field: 1)) = robot.write(&set) else { ... }

// Die zehn größten Winkel über 90°, über den Index rückwärts
query = Database.Query(Joints.table)
query.where(Joints.angle > 90_000)
query.sorted(by: Joints.angle.index, descending: true)
query.limit(10)
page.reset()
while robot.next(&query, into: &page) || page.rowCount > 0 {
    for row in 0..<page.rowCount { let joint = Joints.row(&page, row); _ = joint.angle }
    if page.rowCount == 0 { break }
}

// Join: Bewegungen, deren Gelenk den Status warning hat
query = Database.Query(Moves.table)
query.where(Joints.status.via(Moves.joint) == 1)
query.count()
Alle 134 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
Database.Page.init()
Database.Page.internal(set) var error: DatabaseError?
Database.Page.internal(set) var index: UInt8
Database.Page.internal(set) var plan: UInt8
Database.Page.internal(set) var rowCount
Database.Page.mutating func aggregate(_ row: Int) -> (rows: UInt64, value: Int64?)
Database.Page.mutating func double(_ row: Int, _ field: Int) -> Double
Database.Page.mutating func float(_ row: Int, _ field: Int) -> Float
Database.Page.mutating func groupNumber(_ row: Int) -> Int64
Database.Page.mutating func id(_ row: Int) -> UInt64
Database.Page.mutating func isNull(_ row: Int, _ field: Int) -> Bool
Database.Page.mutating func number(_ row: Int, _ field: Int, signed: Bool = true) -> Int64
Database.Page.mutating func reset()
Database.Page.mutating func text(_ row: Int, _ field: Int) -> TextLine
Database.Page.mutating func value(_ row: Int, _ field: Int) -> (start: Int, length: Int)?
Database.Page.mutating func withBytes<R>(_ row: Int, _ field: Int, _ body: (Span<UInt8>) -> R) -> R?
Database.Page.mutating func withGroupBytes<R>(_ row: Int, _ body: (Span<UInt8>) -> R) -> R?
Database.Query.init(_ table: StaticString)
Database.Query.mutating func `where`(_ condition: Condition)
Database.Query.mutating func average(_ field: Int, groupedBy group: Int? = nil)
Database.Query.mutating func count(groupedBy field: Int? = nil)
Database.Query.mutating func limit(_ rows: Int)
Database.Query.mutating func maximum(_ field: Int, groupedBy group: Int? = nil)
Database.Query.mutating func minimum(_ field: Int, groupedBy group: Int? = nil)
Database.Query.mutating func select(_ field: Int)
Database.Query.mutating func sorted(by field: Int, descending: Bool = false)
Database.Query.mutating func sorted(by field: Int, via ref: NumberField, descending: Bool = false)
Database.Query.mutating func sum(_ field: Int, groupedBy group: Int? = nil)
Database.Query.mutating func whereAny(_ first: Condition, _ second: Condition, _ third: Condition? = nil, _ fourth: Condition? = nil)
Database.Write.init()
Database.Write.internal(set) var insertedCount
Database.Write.internal(set) var insertedIDs
Database.Write.mutating func clear()
Database.Write.mutating func delete(_ table: StaticString, id: UInt64)
Database.Write.mutating func delete(table name: Span<UInt8>, id: UInt64)
Database.Write.mutating func insert(_ table: StaticString, id: UInt64 = 0)
Database.Write.mutating func insert(table name: Span<UInt8>, id: UInt64 = 0)
Database.Write.mutating func set(_ field: Int, bool value: Bool)
Database.Write.mutating func set(_ field: Int, bytes value: Span<UInt8>)
Database.Write.mutating func set(_ field: Int, double value: Double)
Database.Write.mutating func set(_ field: Int, float value: Float)
Database.Write.mutating func set(_ field: Int, int value: Int64, size: Int)
Database.Write.mutating func set(_ field: Int, text line: TextLine)
Database.Write.mutating func set(_ field: Int, text value: StaticString)
Database.Write.mutating func set(_ field: Int, unsigned value: UInt64, size: Int)
Database.Write.mutating func setNull(_ field: Int)
Database.Write.mutating func update(_ table: StaticString, id: UInt64)
Database.Write.mutating func update(table name: Span<UInt8>, id: UInt64)
Database.Write.var isEmpty: Bool
Database.func close()
Database.func describe(into buffer: inout MutableSpan<UInt8>) -> Result<Int, DatabaseError>
Database.func firstValue<R>(query: Span<UInt8>, _ body: (Span<UInt8>?) -> R) -> R
Database.func next<let output: Int, let cursor: Int>(query queryBytes: Span<UInt8>, aggregate: Bool, grouped: Bool,
Database.func next<let q: Int, let output: Int, let cursor: Int>(_ query: inout Database.Query<q>, into page: inout Database.Page<output, cursor>) -> Bool
Database.func write<let capacity: Int>(_ set: inout Database.Write<capacity>, soon: Bool
Database.let handle: DatabaseHandle
Database.static func open(_ path: Span<UInt8>) -> Result<Database, DatabaseError>
Database.static func open(_ path: StaticString, schema: Span<UInt8>) -> Result<Database, DatabaseError>
Database.struct Page<let output: Int, let cursor: Int>
Database.struct Query<let capacity: Int>
Database.struct Write<let capacity: Int>
DatabaseBuffer.init()
DatabaseBuffer.mutating func withBytes<R>(_ body: (Span<UInt8>) -> R) -> R
DatabaseBuffer.mutating func withRoom<R>(_ body: (inout MutableSpan<UInt8>) -> R) -> R
DatabaseBuffer.subscript(index: Int) -> UInt8
DatabaseBuffer.var count
DatabaseRule.var text: StaticString
FieldRef.func via(_ ref: NumberField) -> FieldRef
FieldRef.init(_ index: Int)
FieldRef.internal(set) var joinedThrough
FieldRef.let index: Int
FieldRef.var isNotNull: Condition
FieldRef.var isNull: Condition
FloatField.func via(_ ref: NumberField) -> FloatField
FloatField.init(_ index: Int, double: Bool)
FloatField.internal(set) var joinedThrough
FloatField.let double: Bool
FloatField.let index: Int
FloatField.static func != (field: FloatField, value: Double) -> Condition
FloatField.static func < (field: FloatField, value: Double) -> Condition
FloatField.static func <= (field: FloatField, value: Double) -> Condition
FloatField.static func == (field: FloatField, value: Double) -> Condition
FloatField.static func > (field: FloatField, value: Double) -> Condition
FloatField.static func >= (field: FloatField, value: Double) -> Condition
FloatField.var isNotNull: Condition
FloatField.var isNull: Condition
FloatField.var ref: FieldRef
NumberField.func via(_ ref: NumberField) -> NumberField
NumberField.init(_ index: Int, size: Int, signed: Bool)
NumberField.internal(set) var joinedThrough
NumberField.let index: Int
NumberField.let signed: Bool
NumberField.let size: Int
NumberField.static func != (field: NumberField, value: Int64) -> Condition
NumberField.static func < (field: NumberField, value: Int64) -> Condition
NumberField.static func <= (field: NumberField, value: Int64) -> Condition
NumberField.static func == (field: NumberField, value: Int64) -> Condition
NumberField.static func > (field: NumberField, value: Int64) -> Condition
NumberField.static func >= (field: NumberField, value: Int64) -> Condition
NumberField.var isNotNull: Condition
NumberField.var isNull: Condition
NumberField.var ref: FieldRef
Series.Info.var first: UInt64
Series.Info.var last: UInt64
Series.Info.var recordSize
Series.Info.var records: UInt64
Series.static func info(_ path: Span<UInt8>) -> Result<Info, FileError>
Series.static func read(_ path: Span<UInt8>, from: UInt64, to: UInt64,
Series.struct Info
TextField.func after(_ value: StaticString) -> Condition
TextField.func before(_ value: StaticString) -> Condition
TextField.func contains(_ value: Span<UInt8>) -> Condition
TextField.func contains(_ value: StaticString) -> Condition
TextField.func equals(_ value: Span<UInt8>) -> Condition
TextField.func startsWith(_ value: Span<UInt8>) -> Condition
TextField.func startsWith(_ value: StaticString) -> Condition
TextField.func via(_ ref: NumberField) -> TextField
TextField.init(_ index: Int)
TextField.internal(set) var joinedThrough
TextField.let index: Int
TextField.static func == (field: TextField, value: StaticString) -> Condition
TextField.var isNotNull: Condition
TextField.var isNull: Condition
TextField.var ref: FieldRef
enum DatabaseError: Error, Equatable
enum DatabaseRule: UInt8, Sendable
enum Series
struct Condition
struct Database
struct DatabaseBuffer<let capacity: Int>
struct FieldRef: Sendable
struct FloatField: Sendable
struct NumberField: Sendable
struct TextField: Sendable

network · Netzwerk, TLS, Cloud-KI

Ausgehend mit network.outgoing: TCP (IPv4/IPv6) und UDP zu genau einem Server. Eine Zeile connects = host, host begrenzt die erreichbaren Hosts; Namen löst dann nur der Kern auf. Eingehend mit network.incoming und listens = 443, 80 (nur das Programm Server; nie während eines Not-Halts) – es gibt keinen öffentlichen Webserver, das Tor liegt im Heimnetz plus WireGuard.

TLS 1.3 kommt mit uses-tls als Bibliothek (SecureConnection: Zertifikatskette gegen die Vertrauensanker des Systems, DNS über HTTPS, bis zu 4 Verbindungen). Seit 11.11.2026 liest TLS bis 8 KiB je Systemaufruf, entschlüsselt AES-128/256-GCM mit den AES/PMULL-Befehlen und ChaCha20 mit NEON (beim ersten Verbinden gegen die Software geprüft). Mit uses-ai fragt ein Programm eine Cloud-KI über deren API (Typ Claude); der API-Schlüssel ist das Geheimnis des Programms und wird in Settings › Privatsphäre eingegeben.

Claude (uses-ai) steht in app-api-1.txt; SecureConnection (uses-tls) ist nicht öffentlich deklariert und steht deshalb in keiner der beiden Listen.

Teile nur für Systemprogramme: System-API › network.

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
network.outgoingAusgehende TCP-Verbindungen und UDP; mit connects = eingegrenzt.≤ 5 snetwork.connect0x0005_0004

SystemaufrufenetworkModul 0x0005 · Netzwerk: Namen, TCP, UDP, Lauschen (get/post geplant).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
network.getGet → Responsenetwork.outgoing · vom Kern noch nicht bedient≤ 2 s0x0005_0001
network.postPost → Responsenetwork.outgoing · vom Kern noch nicht bedient≤ 2 s0x0005_0002
network.resolveResolve → Resolvednetwork.outgoing≤ 6 s0x0005_0003
network.connectConnect → Connectednetwork.outgoing≤ 5 s0x0005_0004
network.sendSocketSend → Sentnetwork.outgoing oder network.incoming≤ 1 s0x0005_0005
network.receiveSocketReceive → SocketDatanetwork.outgoing oder network.incoming≤ 10 s0x0005_0006
network.closeSocketRequest → Donenetwork.outgoing oder network.incoming≤ 50 µs0x0005_0007
network.openDatagramDatagramOpen → DatagramOpenednetwork.outgoing≤ 5 s0x0005_0008
network.sendDatagramDatagramSend → Donenetwork.outgoing≤ 1 s0x0005_0009
network.receiveDatagramDatagramReceive → DatagramDatanetwork.outgoing≤ 10 s0x0005_000A
network.closeDatagramDatagramRequest → Donenetwork.outgoing≤ 50 µs0x0005_000B

SystemaufrufeaskModul 0x0050 · Eine Cloud-KI fragen (Reflex-Skripte mit dem Schlüssel aus Settings).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
ask.claudeQuestion → Answerkeins · vom Kern noch nicht bedientohne Budget0x0050_0001

SwiftNetwork.ConnectionEine TCP-Verbindung

AufrufWas er tutShape-Aufruf · Zeitbudget
Namen auflösen
Network.Connection.resolve(_ name: StaticString | Span<UInt8>) -> UInt32?staticIPv4-Adresse eines Hostnamens (DNS des Netzes).≤ 6 snetwork.resolve0x0005_0003
Beispiel
guard let address = Network.Connection.resolve("example.com") else { return }
Muster (kurz, nicht aus einem Programm kopiert)
Network.Connection.resolveIPv6(_ name: Span<UInt8>) -> InlineArray<16, UInt8>?staticIPv6-Adresse (AAAA).≤ 6 snetwork.resolve0x0005_0003
Verbinden
Network.Connection.init?(address: UInt32, port: UInt16)Verbindung öffnen (Handshake läuft im Hintergrund).≤ 5 snetwork.connect0x0005_0004
Beispiel
guard let connection = Network.Connection(address: address, port: 80) else { return }
Muster (kurz, nicht aus einem Programm kopiert)
Network.Connection.init?(ipv6 address: InlineArray<16, UInt8>, port: UInt16)Über IPv6.≤ 5 snetwork.connect0x0005_0004
Senden & empfangen
Network.Connection.send(_ data: Span<UInt8>) -> BoolAlle Bytes senden (wartet bei vollem Puffer).≤ 1 snetwork.send0x0005_0005
Network.Connection.receive(into buffer: inout InlineArray<1024, UInt8>, timeout: UInt64 = 1_000_000_000) -> Int?Bis 1 KiB empfangen; 0 = noch nichts, nil = Gegenseite hat geschlossen.≤ 10 snetwork.receive0x0005_0006
Beispiel
var buffer = InlineArray<1024, UInt8>(repeating: 0)
while let count = connection.receive(into: &buffer, timeout: 2_000_000_000), count > 0 { /* buffer[0..<count] */ }
Muster (kurz, nicht aus einem Programm kopiert)
Schließen
Network.Connection.close()Senderichtung schließen; das System gibt die Verbindung frei, wenn TCP fertig ist.≤ 50 µsnetwork.close0x0005_0007
Senden & empfangen
Network.Connection.receive(area: UnsafeMutableRawBufferPointer, timeout: UInt64 = 1_000_000_000) -> Range<Int>? neuBis 8 KiB direkt in area empfangen (mindestens 8 KiB + 64 Bytes; die Bytes bleiben, wo das System sie hinschrieb). Ergebnis: wo die Bytes in area liegen (leer = noch nichts), nil = Gegenseite hat geschlossen. Liest achtmal seltener als die 1-KiB-Fassung und kopiert im Programm nichts.≤ 10 snetwork.receive0x0005_0006
Beispiel
let area = UnsafeMutableRawBufferPointer.allocate(byteCount: 8192 + 64, alignment: 16)
while let range = connection.receive(area: area, timeout: 2_000_000_000), !range.isEmpty { /* area[range] */ }
Muster (kurz, nicht aus einem Programm kopiert)

SwiftNetwork.DatagramUDP zu einem Server

AufrufWas er tutShape-Aufruf · Zeitbudget
Öffnen
Network.Datagram.init?(address: UInt32, port: UInt16)Verbundener UDP-Socket: Datagramme von anderswo kommen nie an.≤ 5 snetwork.openDatagram0x0005_0008
Senden & empfangen
Network.Datagram.send(_ data: Span<UInt8>) -> BoolEin Datagramm (höchstens 1472 Bytes).≤ 1 snetwork.sendDatagram0x0005_0009
Network.Datagram.receive(into buffer: inout InlineArray<512, UInt8>, timeout: UInt64) -> Int?Ein Datagramm abwarten; 0 wenn keines kam.≤ 10 snetwork.receiveDatagram0x0005_000A
Schließen
Network.Datagram.close()Schließen.≤ 50 µsnetwork.closeDatagram0x0005_000B

SwiftSecureConnectionTLS 1.3 (uses-tls)

AufrufWas er tutShape-Aufruf · Zeitbudget
Verbinden
SecureConnection.open(_ host: StaticString, port: UInt16 = 443, alpn: StaticString = "", timeout: UInt64 = 10_000_000_000) -> SecureConnection?staticAuflösen (DNS über HTTPS), verbinden, Handshake mit Zertifikatsprüfung.≤ 5 snetwork.connect0x0005_0004
Beispiel
guard let secure = SecureConnection.open("example.com") else { return }
aus apps/https (gekürzt)
SecureConnection.open(host: Span<UInt8>, port: UInt16 = 443, timeout: UInt64 = 10_000_000_000) -> SecureConnection?staticFür einen erst zur Laufzeit bekannten Host (Browser).≤ 5 snetwork.connect0x0005_0004
SecureConnection.open(address: UInt32, serverName host: StaticString, port: UInt16 = 443, alpn: StaticString = "", timeout: UInt64 = 10_000_000_000, dns: Bool = false) -> SecureConnection?staticZu einer bekannten Adresse.≤ 5 snetwork.connect0x0005_0004
Senden & empfangen
SecureConnection.send(_ data: Span<UInt8>) -> BoolVerschlüsseln und senden.≤ 1 snetwork.send0x0005_0005
SecureConnection.receive(into out: inout InlineArray<1024, UInt8>, timeout: UInt64 = 5_000_000_000) -> Int?Entschlüsselte Bytes; 0 = noch nichts, nil = geschlossen. Liest intern seit 11.11. bis 8 KiB je Systemaufruf.≤ 10 snetwork.receive0x0005_0006
Beispiel
while let count = secure.receive(into: &buffer) { if count == 0 { break }; total += count }
aus apps/https (gekürzt)
Schließen
SecureConnection.close()close_notify senden und schließen.≤ 50 µsnetwork.close0x0005_0007
Diagnose
SecureConnection.lastError / .handshakeTime / .handshakes / .lastSlotstaticWarum open scheiterte, Dauer des letzten Handshakes.

SwiftClaudeEine Frage an eine Cloud-KI über deren API (uses-ai)

AufrufWas er tutShape-Aufruf · Zeitbudget
Eine Frage an eine Cloud-KI
Claude.ask(_ question: String, jpeg: [UInt8]? = nil, model: String = defaultModel, maxTokens: Int = 700) -> AnswerFragt (optional mit Bild) und wartet auf die ganze Antwort (höchstens eine Minute). Kamerabilder nur, wenn der Besitzer es erlaubt hat.≤ 5 snetwork.connect …0x0005_0004
Beispiel
let result = Claude.ask(String(decoding: question, as: UTF8.self), jpeg: jpeg)
aus apps/ask (gekürzt)
Claude.Answer: text, problem, milliseconds, incompleteAntworttext oder Grund, Dauer.
Beispiel: HTTPS-Abruf mit TLS 1.3 (apps/https)
// manifest: capabilities = system.log, network.outgoing   (+ uses-tls)
guard let secure = SecureConnection.open("example.com") else {
    var line = TextLine("https: ")
    line.append(SecureConnection.lastError)
    System.log(line)
    return
}
let request: StaticString = "GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n"
let sent = request.withUTF8Buffer { bytes in secure.send(Span(_unsafeElements: bytes)) }
guard sent else { System.log("https: sending failed"); return }
var buffer = InlineArray<1024, UInt8>(repeating: 0)
while let count = secure.receive(into: &buffer) {
    if count == 0 { break }
    // ... buffer[0..<count]
}
secure.close()
Beispiel: Klartext-TCP (Muster nach userland/Net.swift)
guard let address = Network.Connection.resolve("example.com"),
      let connection = Network.Connection(address: address, port: 80) else { return }
let request: StaticString = "GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n"
_ = request.withUTF8Buffer { connection.send(Span(_unsafeElements: $0)) }
var buffer = InlineArray<1024, UInt8>(repeating: 0)
while let count = connection.receive(into: &buffer, timeout: 2_000_000_000), count > 0 {
    // ...
}
connection.close()
Beispiel: die Cloud-KI fragen (apps/ask)
// manifest: capabilities = …, network.outgoing, camera.use
//           connects = api.anthropic.com      (+ uses-ai, uses-tls, uses-heap)
let result = Claude.ask(String(decoding: question, as: UTF8.self), jpeg: jpeg)
if let problem = result.problem {
    // problem: warum es keine Antwort gibt (kein Schlüssel, kein Netz …)
} else {
    answer = Array(result.text.utf8)
}
Alle 27 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
Claude.Answer.var incomplete
Claude.Answer.var milliseconds: UInt64
Claude.Answer.var problem: String?
Claude.Answer.var text
Claude.static func ask(_ question: String, jpeg: [UInt8]? = nil, model: String = defaultModel, maxTokens: Int = 700) -> Answer
Claude.static let defaultModel
Claude.static let host
Claude.struct Answer
Network.Connection.func close()
Network.Connection.func receive(area: UnsafeMutableRawBufferPointer, timeout: UInt64 = 1_000_000_000) -> Range<Int>?
Network.Connection.func receive(into buffer: inout InlineArray<1024, UInt8>, timeout: UInt64 = 1_000_000_000) -> Int?
Network.Connection.func send(_ data: Span<UInt8>) -> Bool
Network.Connection.init?(address: UInt32, port: UInt16)
Network.Connection.init?(ipv6 address: InlineArray<16, UInt8>, port: UInt16)
Network.Connection.let handle: SocketHandle
Network.Connection.static func resolve(_ name: Span<UInt8>) -> UInt32?
Network.Connection.static func resolve(_ name: StaticString) -> UInt32?
Network.Connection.static func resolveIPv6(_ name: Span<UInt8>) -> InlineArray<16, UInt8>?
Network.Datagram.func close()
Network.Datagram.func receive(into buffer: inout InlineArray<512, UInt8>, timeout: UInt64) -> Int?
Network.Datagram.func send(_ data: Span<UInt8>) -> Bool
Network.Datagram.init?(address: UInt32, port: UInt16)
Network.Datagram.let handle: DatagramHandle
Network.struct Connection
Network.struct Datagram
enum Claude
enum Network

ui · Fenster, Zeichnen, Views, Eingabe, Menüs, Fortschritt

Ein Fenster ist eine Surface: Pixelspeicher und ein Nachrichtenring, die der Kern ins Programm und in den Display-Dienst einblendet. Das System zeichnet Rahmen, Titel und Menüleiste; das Programm zeichnet seinen Inhalt mit Canvas oder beschreibt ihn mit Views (VStack, Text, Button …), Farben kommen aus UITheme. Die Ereignisschleife: nextEvent() bis nil, zeichnen, present, wait. Jedes switch über SurfaceEvent braucht default: (neue Fälle kommen dazu).

Menüs beschreibt das Programm, das System zeichnet sie in der Menüleiste (Index 0 … 5) und im Kontextmenü (SurfaceMessage.contextMenuIndex). Gewählte Punkte kommen als .menu(id:). Für Datei und Bearbeiten gibt es Standardmenüs mit festen ids und Kürzeln (⌘N ⌘O ⌘S ⇧⌘S ⌘E; ⌘Z ⌘X ⌘C ⌘V ⌘A).

Neu (10.11.). Ein Programm sagt, was es tut und wie weit es ist („wie viel von wie viel“); das System zeichnet es überall gleich: eine Kapsel im Fenstertitel mit Balken, Prozent und Restzeit, ein dünner Balken auf der Dock-Kachel; ein Klick zeigt Details und – wenn erlaubt – Abbrechen. Buddy meldet, wenn eine lange Aufgabe fertig ist, während das Fenster nicht vorn ist. Höchstens 4 Aufgaben pro Fenster; Meldungen gehen höchstens 10-mal pro Sekunde raus. Kein eigenes Recht nötig (das Fenster genügt, ui.surface).

Teile nur für Systemprogramme: System-API › ui.

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
ui.surfaceFenster zeigen (bis zu drei).≤ 5 msdisplay.createSurface0x0011_0004

SystemaufrufedisplayModul 0x0011 · Bildschirm und Fensterspeicher (ui.surface, ui.display).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
display.createSurfaceDisplayQuery → SurfaceMemoryui.surface≤ 5 ms0x0011_0004

SystemaufrufescreenModul 0x0010 · Fenster als Beschreibung von Views (Reflex).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
screen.showScreenView → Donekeins · vom Kern noch nicht bedient≤ 200 µs0x0010_0001
screen.ScreenView effectReflex-EffektEffekt0x0010_0002
screen.pressed eventPressedReflex-EreignisEreignis0x0010_0003
screen.slid eventSlidReflex-EreignisEreignis0x0010_0004
screen.key eventKeyPressReflex-EreignisEreignis0x0010_0005

SwiftSurfaceFenster des Programms

AufrufWas er tutShape-Aufruf · Zeitbudget
Fenster anlegen
Surface.create(timeout: UInt64 = 10_000_000_000) -> Surface?staticFordert ein Fenster an (bis zu drei pro Programm), wartet notfalls auf den Display-Dienst.≤ 5 msdisplay.createSurface0x0011_0004
Beispiel
guard var surface = Surface.create() else { System.log("text: no window"); return }
aus apps/text (gekürzt)
Surface.requestSize(width: Int, height: Int)Gewünschte Inhaltsgröße (der Nutzer kann sie ändern).
Beispiel
surface.requestSize(width: 1120, height: 720)
aus apps/sound (gekürzt)
Surface.setTitle(_ text: TextLine)Name über dem Fenster.
Beispiel
window.setTitle(TextLine("Web"))
aus apps/web (gekürzt)
Surface.destroy()Schließt eines von mehreren Fenstern (bei nur einem: einfach beenden).
Beispiel
guard var second = Surface.create() else { return }
// ... später, bei .close dieses Fensters:
second.destroy()
Muster (kurz, nicht aus einem Programm kopiert)
Ereignisse holen
Surface.nextEvent() -> SurfaceEvent?Nächste Nachricht des Dienstes, nil wenn keine wartet; .configure passt canvas an.
Beispiel
while let event = surface.nextEvent() {
    switch event {
    case .configure: dirty = true
    case .close: System.exit(0)
    default: break
    }
}
aus sdk-apps/greeter (gekürzt)
Surface.wait(timeout: UInt64)Schläft, bis der Dienst etwas schickt oder timeout ns vergehen.wait (Systemaufruf 3)
Beispiel
surface.wait(timeout: 500_000_000)   // 0,5 s oder bis ein Ereignis kommt
aus apps/reader (gekürzt)
Zeichnen & zeigen
Surface.canvas: CanvasDie Zeichenfläche, die der Dienst gegeben hat (leer bis zum ersten configure).
Surface.beginDrawing()Vor einem Bild aufrufen: der Dienst kopiert das Fenster erst nach present (kein Reißen).
Beispiel
surface.beginDrawing()
draw(surface.canvas)
surface.presentChanges()
aus apps/reader (gekürzt)
Surface.present(_ rect: Rect) -> BoolZeigt das geänderte Rechteck; false wenn der Ring voll blieb (später erneut zeigen).
Beispiel
surface.present(Rect(x: 0, y: 0, width: surface.canvas.width, height: surface.canvas.height))
aus sdk-apps/greeter (gekürzt)
Surface.presentChanges()Zeigt alle seit beginDrawing geänderten Kacheln (DamageTracker).
Zeiger, Vordergrund, Ziehen
Surface.setPointer(_ shape: PointerShape)Zeigerform über dem Inhalt (.hand, .text, .arrow, .resize…).
Beispiel
surface.setPointer(ui.button(at: x, y) != 0 ? .hand : .arrow)
aus sdk-apps/greeter (gekürzt)
Surface.raise()Holt das Fenster nach vorn (z. B. nach einem übergebenen Dokument).
Beispiel
if openHandedOver() { surface.raise(); dirty = true }   // Doppelklick in Files: nach vorn
aus apps/database (gekürzt)
Surface.carry()Lässt den Nutzer ein Dokument ziehen; Antwort kommt als .dropped.
Beispiel
case .pointer(let x, let y, let buttons):
    if buttons & 2 != 0 && overDocument(x, y) { surface.carry() }
case .dropped(let program, let length, _, _):
    if length > 0 { /* über program[0..<length] losgelassen */ }
Muster (kurz, nicht aus einem Programm kopiert)
Interna
Surface.handle: UInt64Nummer des Fensters (für Systemaufruf surfaceNotify).
Surface.frameCounter / .frameShownstaticByte-Offsets im Ringblatt: Bildzähler (ungerade = wird gezeichnet) und zuletzt gezeigtes Bild.

SwiftSurfaceEventWas der Dienst dem Programm meldet

AufrufWas er tutShape-Aufruf · Zeitbudget
Fenster
SurfaceEvent.configure(width: Int, height: Int)caseGröße geändert / Fenster bereit: neu zeichnen.
SurfaceEvent.focus(Bool)caseFenster bekommt/verliert den Fokus.
SurfaceEvent.closecaseNutzer hat das Fenster geschlossen (⌘W): Programm beenden.
Eingabe
SurfaceEvent.key(code: UInt8, down: Bool)caseTaste (HID-Code); durch Keyboard.handle schicken.
Beispiel
case .key(let code, let down):
    let press = keyboard.handle(code: code, down: down)
aus apps/reader (gekürzt)
SurfaceEvent.pointer(x: Int, y: Int, buttons: UInt32)caseZeiger bewegt / Taste; Bit 1 (Wert 2) = Primärtaste gedrückt.
SurfaceEvent.scroll(x: Int, y: Int, tenths: Int)caseMausrad in Zehntel-Rasten, positiv vom Nutzer weg.
Beispiel
case .scroll(let x, let y, let tenths):
    scrollY = max(0, scrollY - tenths * 6)
aus apps/reader (gekürzt)
Menü & Ziehen
SurfaceEvent.menu(id: Int)caseEin Menüpunkt (Menüleiste, Kontextmenü oder Kürzel) wurde gewählt.
SurfaceEvent.dropped(program: InlineArray<32, UInt8>, length: Int, x: Int, y: Int)caseGetragenes Dokument wurde über einem Programm losgelassen.

SwiftSurfaceMenüs beschreiben

AufrufWas er tutShape-Aufruf · Zeitbudget
Menü aufbauen
Surface.addMenu(_ index: Int, _ title: StaticString)Menü Nummer index (0 … 5 Menüleiste, SurfaceMessage.contextMenu für Rechtsklick).
Beispiel
surface.addMenu(2, "View")
aus apps/reader (gekürzt)
Surface.addItem(_ index: Int, _ title: StaticString, id: Int, key: UInt8 = 0, enabled: Bool = true, icon: MenuIcon = .none, toggle: Bool? = nil)Menüpunkt; key = Buchstabe des ⌘-Kürzels; mit icon ein großer Knopf oben im Menü; toggle = Schalter.
Beispiel
surface.addItem(2, "Zoom In", id: Item.zoomIn, key: 0x2B, icon: .zoomIn)   // ⌘+
aus apps/reader (gekürzt)
Surface.addSeparator(_ index: Int)Trennlinie.
Beispiel
surface.addSeparator(2)
aus apps/reader (gekürzt)
Surface.publishMenus()Menüs an den Dienst schicken (nach allen add…).
Beispiel
surface.addMenu(0, "Counter")
surface.addItem(0, "Count", id: Buttons.count, key: 0x6E) // ⌘N
surface.publishMenus()
aus sdk-apps/greeter (gekürzt)
Surface.clearMenus()Alle Menüs entfernen, danach neu senden.
Punkte schalten
Surface.setItem(_ id: Int, enabled: Bool)Punkt wählbar oder grau.
Beispiel
surface.setItem(Buttons.delete, enabled: place != 2)
aus apps/files (gekürzt)
Surface.setItem(_ id: Int, on: Bool)Schalter-Punkt ein/aus.
Beispiel
surface.setItem(Item.pages, on: !showOutline)   // Schalter-Punkt nachführen
Muster (kurz, nicht aus einem Programm kopiert)
Standardmenüs
Surface.addFileMenu(_ index: Int = 0, new: StaticString = "", open: Bool = false, save: Bool = false, saveAs: Bool = false, export: Bool = false, showInFiles: Bool = false) neuDas Standard-Dateimenü: nur die Punkte, die das Programm kann, in Systemreihenfolge mit Systemkürzeln.
Beispiel
surface.addFileMenu(new: "New Script", open: true, save: true, export: true)
aus apps/develop (gekürzt)
Surface.addEditMenu(_ index: Int, contextMenu: Bool = true)Das Standard-Bearbeiten-Menü (auch im Kontextmenü); ids an das fokussierte InputField geben.
Beispiel
surface.addEditMenu(1)   // Menü 1 und Kontextmenü
aus apps/reader (gekürzt)

SwiftFileMenu · EditMenu · MenuIconStandardmenüs

AufrufWas er tutShape-Aufruf · Zeitbudget
File-Menü
FileMenu.new / .open / .save / .saveAs / .export / .showInFiles (911 … 916) neuids des Standard-Dateimenüs.
FileMenu.contains(_ id: Int) -> Bool neuGehört die id zum Dateimenü?
Beispiel
case .menu(let id):
    if FileMenu.contains(id) { fileCommand(id) }
    else if EditMenu.contains(id) { _ = field.command(id) }
Muster (kurz, nicht aus einem Programm kopiert)
Bearbeiten-Menü
EditMenu.undo / .redo / .cut / .copy / .paste / .selectAll (901 … 906)ids des Bearbeiten-Menüs; bei Paste gibt der Dienst die Zwischenablage frei.
EditMenu.contains(_ id: Int) -> BoolGehört die id zum Bearbeiten-Menü?
Symbole
enum MenuIcon: none, folder, rename, delete, compress, extract, refresh, start, up, zoomIn, zoomOut, fit, actualSize, clear, list, log, copySymbole für Menüpunkte (vom Dienst gezeichnet).

SwiftSurfaceFortschritt melden

AufrufWas er tutShape-Aufruf · Zeitbudget
Aufgabe starten
Surface.progress(_ title: TextLine, total: UInt64, unit: ProgressUnit = .none, cancellable: Bool = false) -> ProgressTask? neuStartet eine Aufgabe im Titel und im Dock; total 0 = unbekannt (laufender Streifen). Nil bei schon 4 Aufgaben.surfaceNotify (Systemaufruf 11)
Beispiel
guard let task = surface.progress(TextLine("Export 1200 rows"), total: 1200, unit: .items, cancellable: true) else { return }
Muster (kurz, nicht aus einem Programm kopiert)
Stand melden
Surface.progress(_ task: ProgressTask, done: UInt64) neuWie weit die Aufgabe ist (gedrosselt auf 10/s).
Beispiel
surface?.progress(running, done: UInt64(response.body.count))
aus apps/web (gekürzt)
Beenden
Surface.progress(_ task: ProgressTask, finished end: ProgressEnd, done: UInt64? = nil) neuAufgabe beendet; bleibt kurz grün (oder rot) im Titel.
Beispiel
surface?.progress(running, finished: cancelled ? .cancelled : result.problem == nil ? .done : .failed)
aus apps/web (gekürzt)
Abbrechen erkennen
Surface.isCancelled(_ task: ProgressTask) -> Bool neuHat die Person Abbrechen gedrückt? Jederzeit fragen, auch mitten in einer Schleife.
Beispiel
if surface?.isCancelled(running) == true { cancelled = true; break }
aus apps/web (gekürzt)
Surface.cancelRequestsstatic neuByte-Offset der Abbruch-Bits im Ringblatt (ein Bit pro Aufgabe).

SwiftProgressUnit · ProgressEnd · ProgressTaskTypen des Fortschritts

AufrufWas er tutShape-Aufruf · Zeitbudget
Typen
enum ProgressUnit: UInt8 { none, bytes, items } neuWas done und total zählen.
enum ProgressEnd: UInt8 { done, failed, cancelled } neuWie eine Aufgabe endete.
struct ProgressTask { let id: Int } neuEine laufende Aufgabe des Fensters.
SurfaceMessage.progress neuNachrichtenart 12 (Programm → Dienst).

SwiftCanvasZeichnen in Pixeln (logische Punkte × scale)

AufrufWas er tutShape-Aufruf · Zeitbudget
Flächen
Canvas.fill(_ rect: Rect, _ color: RGB)Rechteck füllen.
Beispiel
canvas.fill(Rect(x: 0, y: 0, width: canvas.width, height: 40), UITheme.raised)
Muster (kurz, nicht aus einem Programm kopiert)
Canvas.gradient(_ rect: Rect, from top: RGB, to bottom: RGB)Senkrechter Verlauf.
Canvas.blend(_ rect: Rect, _ color: RGB, alpha: UInt32)Halbtransparent überlagern.
Beispiel
canvas.blend(Rect(x: x - thick / 2, y: y - thick / 2, width: thick, height: thick), colour, alpha: alpha)
aus apps/develop (gekürzt)
Canvas.smoothRect(_ rect: Rect, radius: Int, top: RGB, bottom: RGB)Abgerundetes Rechteck mit Verlauf, kantengeglättet.
Text
Canvas.text(_ line: TextLine, x: Int, y: Int, color: RGB, scale requested: Int = 1) -> IntText in der Bitmap-Schrift; gibt die Breite zurück.
Canvas.text(_ text: TextLine, x: Int, baseline: Int, face: FontFace, color: RGB) -> IntText in einer Systemschrift (.body, .heading …) auf eine Grundlinie.
Beispiel
canvas.text(TextLine("RECORDINGS"), x: area.x + 16, baseline: area.y + 26, face: .caption, color: UITheme.muted)
aus apps/sound (gekürzt)
Canvas.width(_ text: TextLine, face: FontFace) -> IntstaticBreite eines Texts in einer Schrift.
Beispiel
let plus = Rect(x: minus.right + 24 + Canvas.width(TextLine("100 %"), face: .body), y: soundY - 21, width: 32, height: 32)
aus apps/sound (gekürzt)
Canvas.textWidth(_ line: TextLine, scale: Int = 1) -> IntstaticBreite in der Bitmap-Schrift.
Pixel & Farben
Canvas.pixel(_ x: Int, _ y: Int) -> UInt32 / .setPixel(_:_:_:)Einzelnen Punkt lesen/setzen (im Bildschirmformat).
Canvas.encode(_ color: RGB) -> UInt32 / .decode(_ value: UInt32) -> RGBFarbe ↔ Pixelwert.
Canvas.copy(from base: UInt64, stride sourceStride: Int, rect: Rect, to x: Int, _ y: Int, limit: Rect)Pixel aus einem anderen Speicher kopieren (Bilder, Video).
Teilflächen
Canvas.region(_ rect: Rect) -> CanvasTeilfläche als eigene Canvas (Ursprung verschoben, beschnitten).
Beispiel
let sidebar = canvas.region(Rect(x: 0, y: 0, width: 210, height: canvas.height))
sidebar.fill(Rect(x: 0, y: 0, width: 210, height: canvas.height), UITheme.ground)
Muster (kurz, nicht aus einem Programm kopiert)
Canvas.clip(_ rect: Rect) -> RectRechteck auf die Fläche beschneiden.
Canvas.scaled(_ scale: Int) -> CanvasDieselbe Fläche mit anderem Maßstab.
Views zeichnen
Canvas.render<V: View>(_ view: V, in rect: Rect, _ ui: inout UI, background: RGB = UITheme.background)Views messen und zeichnen; Buttons werden in ui eingetragen.
Beispiel
canvas.render(view, in: Rect(x: 0, y: 0, width: canvas.width, height: canvas.height), &ui)
aus sdk-apps/greeter (gekürzt)
Maße
Canvas.width, .height, .scale, .stride, .pixelWidth, .pixelHeight, .baseMaße (logisch und physisch) und Speicheradresse.

SwiftViewsInhalt beschreiben statt zeichnen

AufrufWas er tutShape-Aufruf · Zeitbudget
Anordnen
VStack(spacing: Int = 8, @ViewBuilder _ content: () -> Content)Untereinander anordnen.
Beispiel
let view = Padded(20) {
    VStack(spacing: 14) {
        Text("greeter", face: .heading)
        Button("Count", id: Buttons.count)
        Spacer()
    }
}
aus sdk-apps/greeter (gekürzt)
HStack(spacing: Int = 8, @ViewBuilder _ content: () -> Content)Nebeneinander anordnen.
Padded(_ amount: Int, @ViewBuilder _ content: () -> Content)Innenabstand um einen Stapel.
Spacer() / Divider()Dehnbarer Leerraum / Trennlinie.
Inhalte
Text(_ text: StaticString | TextLine, face: FontFace = .body, color: RGB = UITheme.text)Ein Text in Systemschrift.
Button(_ title: StaticString | TextLine, id: Int, prominent: Bool = true, tint: RGB = UITheme.accent)Knopf; seine id liefert ui.button(at:).
ProgressBar (value, maximum, color)Fortschrittsbalken im Inhalt (für Aufgaben im Titel: Fortschritt).
Eigene Views
protocol View: measure(_:) / draw(in:on:_:) / flexible / compressibleEigene Views: messen und zeichnen.

SwiftUIKnöpfe, Fokus, Tastatur-Navigation

AufrufWas er tutShape-Aufruf · Zeitbudget
Knöpfe
UI.init()Leerer Zustand (global halten).
UI.button(at x: Int, _ y: Int) -> Intid des Knopfs unter dem Zeiger (0: keiner).
Beispiel
let under = ui.button(at: x, y)   // 0: kein Knopf
aus sdk-apps/greeter (gekürzt)
UI.pressed / .focusedGedrückter bzw. fokussierter Knopf.
UI.button(_ canvas: Canvas, _ rect: Rect, id: Int, _ title: TextLine, kind: ButtonKind = .secondary, size: ButtonSize = .regular, symbol: ButtonSymbol? = nil, enabled: Bool = true, background: RGB = UITheme.background)Einen Knopf direkt zeichnen und eintragen (ohne Views).
Beispiel
ui.button(canvas, plus, id: Buttons.louder, louder, kind: .secondary)
aus apps/settings (gekürzt)
UI.beginFrame() / .addButton(_ id: Int, _ rect: Rect)Neues Bild beginnen / eigenen Bereich als Knopf eintragen.
Tastatur-Navigation
UI.key(_ press: Keyboard.Result, shift: Bool) -> IntTab bewegt den Fokus, Enter/Leertaste drückt; gibt die id des gedrückten Knopfs.
Beispiel
let press = keyboard.handle(code: code, down: down)
let pressed = ui.key(press, shift: keyboard.shift)
if pressed == Buttons.count { clicks += 1 }
Muster (kurz, nicht aus einem Programm kopiert)

SwiftUITheme · ButtonLook · FileLookDie Farben und der Knopf-Look des Systems

AufrufWas er tutShape-Aufruf · Zeitbudget
Farben
UITheme.background, .ground, .raised, .line, .text, .muted, .faint, .accent, .accentPressed, .onAccent, .good, .warning …staticSystemfarben (dunkel oder hell, je nach Einstellung des Besitzers).
UITheme.codeKeyword, .codeValue, .codeComment, .codeShapestaticFarben für Quelltext (Develop).
UITheme.use(light: Bool) / UITheme.isLight: BoolstaticHelle oder dunkle Palette wählen / abfragen.
Beispiel
UITheme.use(light: true)   // helle Palette; danach neu zeichnen
Muster (kurz, nicht aus einem Programm kopiert)
UIDesign.dark / UIDesign.lightstaticDie beiden Paletten als UIDesign-Werte.
Knopf-Look
ButtonLook.draw(_ canvas: Canvas, _ rect: Rect, _ kind: ButtonKind, _ size: ButtonSize, title: TextLine? = nil, symbol: ButtonSymbol? = nil, state: ButtonState = ButtonState(), background: RGB = UITheme.background)Knopf im Systemlook zeichnen (Varianten nach ButtonKind, Größen nach ButtonSize).
ButtonLook.width(_ title: TextLine, _ size: ButtonSize) -> IntBreite eines Knopfs.
ButtonLook.drawSymbol / .roundedFill / .coloursSymbol, gerundete Fläche, Farben eines Zustands.
Dateifarben
FileLook.colour(_ name: Span<UInt8>) -> RGBFarbe, mit der Files einen Dateityp zeigt.

SwiftKeyboardEingabe: Tastencodes zu Zeichen

AufrufWas er tutShape-Aufruf · Zeitbudget
Tasten auswerten
Keyboard.init()Zustand der Umschalttasten.
Keyboard.handle(code: UInt8, down: Bool) -> ResultWertet ein .key-Ereignis aus: .character, .text, .special(…) oder .none.
Beispiel
let press = keyboard.handle(code: code, down: down)
switch press {
case .special(.down): scrollY += 40
case .character(0x20): scrollY += area.height - 40
default: break
}
aus apps/reader (gekürzt)
Keyboard.utf8(_ code: UInt32, into out: inout InlineArray<4, UInt8>) -> IntstaticEin Zeichen als UTF-8.
Umschalttasten
Keyboard.shift, .control, .option, .command, .altGrGedrückte Umschalttasten.

SwiftInputFieldEingabe: ein Feld mit Auswahl, Undo und Zwischenablage

AufrufWas er tutShape-Aufruf · Zeitbudget
Anlegen
InputField.init(maximumLength: Int = 512, secret: Bool = false)Feld anlegen; secret zeigt Punkte (Passwörter).
Beispiel
nonisolated(unsafe) var passwordInput = InputField(maximumLength: 127, secret: true)
passwordInput.placeholder = TextLine("Password")
aus apps/reader (gekürzt)
Eingabe weitergeben
InputField.key(_ press: Keyboard.Result, _ keyboard: Keyboard) -> ChangeTaste, solange das Feld den Fokus hat; Ergebnis .none/.moved/.edited/.submit/.cancel.
Beispiel
switch passwordInput.key(press, keyboard) {
case .submit: submitPassword()
case .none: return false
default: break
}
aus apps/reader (gekürzt)
InputField.command(_ id: Int) -> ChangeBefehl des Bearbeiten-Menüs (EditMenu-ids) ausführen.
Beispiel
if searchFocused { let change = searchInput.command(id); if change == .edited { search() } }
aus apps/reader (gekürzt)
InputField.pointer(_ x: Int, _ y: Int, down: Bool, pressed: Bool) -> BoolZeiger-Ereignis (Klick, Ziehen); true wenn das Feld es nahm.
Beispiel
if editing && queryInput.pointer(x, y, down: down, pressed: pressed) { surface.setPointer(.text); dirty = true }
aus apps/database (gekürzt)
Zeichnen
InputField.draw(_ canvas: Canvas, _ rect: Rect, focused: Bool)Feld zeichnen: Rahmen, Text, Auswahl, Cursor.
Beispiel
searchInput.draw(canvas, field, focused: searchFocused)
aus apps/reader (gekürzt)
InputField.contains(_ x: Int, _ y: Int) -> BoolLiegt der Zeiger über dem Feld (für den Text-Zeiger)?
Inhalt setzen & lesen
InputField.set(_ text: Span<UInt8> | TextLine) / .clear()Text ersetzen / leeren.
InputField.select(from start: Int, to end: Int)Cursor und Auswahl setzen.
InputField.withBytes<R>(_ body: (Span<UInt8>) -> R) -> R / .line: TextLineDen Inhalt lesen (Bytes oder erste 160 Bytes als Zeile).
Beispiel
var password: [UInt8] = []
passwordInput.withBytes { for byte in $0 { password.append(byte) } }
aus apps/reader (gekürzt)
Eigenschaften
InputField.placeholder, .bordered, .secret, .face, .textColour, .cursorColour, .maximumLengthAussehen und Verhalten.
InputField.isEmpty, .hasSelection / .cursor, .anchor, .count, .frameZustand des Felds.

SwiftRect · Size · RGBGrundtypen

AufrufWas er tutShape-Aufruf · Zeitbudget
Grundtypen
Rect(x: Int, y: Int, width: Int, height: Int) / .right / .bottomEin Rechteck in Fensterpunkten.
Size(width: Int, height: Int)Eine Größe (Views messen damit).
RGB(_ red: UInt8, _ green: UInt8, _ blue: UInt8) / .mixed(with other: RGB, _ amount: UInt32) -> RGBEine Farbe; Mischung zweier Farben.
Canvas.physicalPixel(_:_:) / .setPhysicalPixel(_:_:_:) / .shiftsPixel im physischen Raster (ohne scale) und Farbformat des Bildschirms.

SwiftScrollBar · ListBar · Chart · DamageTrackerBausteine

AufrufWas er tutShape-Aufruf · Zeitbudget
Rollbalken
ScrollBar.draw(_ canvas: Canvas, _ rect: Rect, total: Int, visible: Int, offset: Int, active: Bool = false)Rollbalken im Systemlook (Variante B).
Beispiel
ScrollBar.draw(canvas, listBar, total: entryCount, visible: visibleRows, offset: scroll, active: listBarGrab != nil)
aus apps/files (gekürzt)
ScrollBar.needed / .thumb / .part(at:…) / .offset(after:…) / .offset(dragTo:…)Braucht es einen Balken, wo liegt der Griff, Klick und Ziehen auswerten.
ListBar.place(_ area: Rect, total: Int, visible: Int) -> Int / .pointer(…) / .draw(_:offset:)Rollbalken für Listen mit eigenem Zustand.
Diagramme
Chart.frame(_ canvas: Canvas, _ rect: Rect, low: Double, high: Double, lines: Int, labelWidth: Int, …, label: (Double) -> TextLine) -> PlotDiagrammrahmen mit Gitter und Beschriftung; liefert die Zeichenfläche.
Beispiel
let plot = Chart.frame(canvas, panel, low: 0, high: Double(top), lines: 5, labelWidth: 48, rightRoom: 58) { value in
    var line = TextLine(); line.append(decimal: UInt64(value)); return line
}
aus apps/activity (gekürzt)
Chart.series(_ canvas: Canvas, _ plot: Plot, count: Int, slots: Int, colour: RGB, area: Bool, value: (Int) -> Double)Eine Messreihe als Linie oder Fläche.
Beispiel
Chart.series(canvas, plot, count: values.count, slots: historyLength, colour: Chart.cpu, area: true) { index in
    values[index]
}
aus apps/activity (gekürzt)
Chart.cursor / .endPoint / .dot / .niceTop / .roundedPanelCursor, Endpunkt mit Wert, Punkt, runde Obergrenze, Panel.
Plot(area: Rect, low: Double, high: Double): x(of:count:slots:) / .y(_:) / .index(at:count:slots:)Umrechnung Wert ↔ Pixel.
Geänderte Kacheln
DamageTracker.changes(_ canvas: Canvas, handle: UInt64, _ changed: (Rect) -> Void)Findet geänderte Kacheln (für presentChanges).
Beispiel: Ein Fenster mit Menü, Knopf und Ereignisschleife (sdk-apps/greeter)
nonisolated(unsafe) var ui = UI()
nonisolated(unsafe) var clicks = 0

enum Buttons { static let count = 1 }

@c(app_main)
func appMain() {
    guard var surface = Surface.create() else { System.log("greeter: no window"); return }
    surface.requestSize(width: 360, height: 220)
    surface.addMenu(0, "Counter")
    surface.addItem(0, "Count", id: Buttons.count, key: 0x6E) // Cmd+N
    surface.publishMenus()
    var dirty = true
    while true {
        while let event = surface.nextEvent() {
            switch event {
            case .configure: dirty = true
            case .close: System.exit(0)
            case .menu(let id): if id == Buttons.count { clicks += 1; dirty = true }
            case .pointer(let x, let y, let buttons):
                let under = ui.button(at: x, y)
                surface.setPointer(under != 0 ? .hand : .arrow)
                if buttons & 2 != 0 {
                    if ui.pressed == 0 { ui.pressed = under; dirty = true }
                } else if ui.pressed != 0 {
                    if under == ui.pressed && under == Buttons.count { clicks += 1 }
                    ui.pressed = 0
                    dirty = true
                }
            default: break
            }
        }
        if dirty && surface.canvas.width > 0 {
            draw(surface.canvas)
            surface.present(Rect(x: 0, y: 0, width: surface.canvas.width, height: surface.canvas.height))
            dirty = false
        }
        surface.wait(timeout: 500_000_000)
    }
}
Beispiel: Inhalt mit Views beschreiben (sdk-apps/greeter)
private func draw(_ canvas: Canvas) {
    var text = TextLine("Clicked ")
    text.append(decimal: UInt64(clicks))
    text.append(clicks == 1 ? " time" : " times")
    let view = Padded(20) {
        VStack(spacing: 14) {
            Text("greeter", face: .heading)
            Text(text, face: .body, color: UITheme.muted)
            Button("Count", id: Buttons.count)
            Spacer()
        }
    }
    canvas.render(view, in: Rect(x: 0, y: 0, width: canvas.width, height: canvas.height), &ui)
}
Beispiel: Tastatur und Suchfeld (apps/reader)
nonisolated(unsafe) var keyboard = Keyboard()
nonisolated(unsafe) var searchInput = InputField(maximumLength: 120)

// beim Start
searchInput.placeholder = TextLine("Search")

// bei case .key(let code, let down):
let press = keyboard.handle(code: code, down: down)
if searchFocused {
    switch searchInput.key(press, keyboard) {
    case .edited: search(); return true
    case .submit: return step(keyboard.shift ? -1 : 1, canvas)
    case .cancel: searchFocused = false; return true
    case .moved: return true
    case .none: break
    }
}

// beim Zeichnen
searchInput.draw(canvas, field, focused: searchFocused)
Beispiel: Nur geänderte Teile zeigen (apps/reader)
if dirty && surface.canvas.width > 0 {
    surface.beginDrawing()      // der Dienst kopiert jetzt nicht mitten ins Bild
    draw(surface.canvas)
    surface.presentChanges()    // nur die geänderten Kacheln
    dirty = false
}
surface.wait(timeout: 500_000_000)
Beispiel: Download mit Fortschritt und Abbrechen (apps/web, Fetch.swift, gekürzt)
// Lange Antworten zeigen ihren Fortschritt (das System zeichnet ihn).
if task == nil {
    task = surface?.progress(TextLine("Download Big_Buck_Bunny.webm"),
                             total: UInt64(response.expectedLength ?? 0), unit: .bytes, cancellable: true)
}
if let running = task {
    surface?.progress(running, done: UInt64(response.body.count))
    if surface?.isCancelled(running) == true {
        cancelled = true
        break
    }
}

// am Ende (defer):
if let running = task {
    surface?.progress(running, finished: cancelled ? .cancelled : result.problem == nil ? .done : .failed)
    task = nil
}
Alle 354 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
Button.func draw(in rect: Rect, on canvas: Canvas, _ ui: inout UI)
Button.func measure(_ proposal: Size) -> Size
Button.init(_ title: StaticString, id: Int, prominent: Bool = true, tint: RGB = UITheme.accent)
Button.init(_ title: TextLine, id: Int, prominent: Bool = true, tint: RGB = UITheme.accent)
Button.let id: Int
Button.let title: TextLine
Button.var prominent
Button.var tint
ButtonLook.static func colours(_ kind: ButtonKind, _ state: ButtonState, background: RGB) -> (fill: RGB?, text: RGB)
ButtonLook.static func draw(_ canvas: Canvas, _ rect: Rect, _ kind: ButtonKind, _ size: ButtonSize, title: TextLine? = nil,
ButtonLook.static func drawSymbol(_ canvas: Canvas, _ symbol: ButtonSymbol, x: Int, y: Int, size: Int, _ colour: RGB)
ButtonLook.static func roundedFill(_ canvas: Canvas, _ rect: Rect, radius: Int, _ colour: RGB)
ButtonLook.static func width(_ title: TextLine, _ size: ButtonSize) -> Int
ButtonSize.var height: Int
ButtonSize.var padding: Int
ButtonSize.var radius: Int
ButtonState.init(hovered: Bool = false, pressed: Bool = false, enabled: Bool = true, focused: Bool = false)
ButtonState.var enabled
ButtonState.var focused
ButtonState.var hovered
ButtonState.var pressed
Canvas.func blend(_ rect: Rect, _ color: RGB, alpha: UInt32)
Canvas.func clip(_ rect: Rect) -> Rect
Canvas.func copy(from base: UInt64, stride sourceStride: Int, rect: Rect, to x: Int, _ y: Int, limit: Rect)
Canvas.func decode(_ value: UInt32) -> RGB
Canvas.func encode(_ color: RGB) -> UInt32
Canvas.func fill(_ rect: Rect, _ color: RGB)
Canvas.func gradient(_ rect: Rect, from top: RGB, to bottom: RGB)
Canvas.func physicalPixel(_ x: Int, _ y: Int) -> UInt32
Canvas.func pixel(_ x: Int, _ y: Int) -> UInt32
Canvas.func region(_ rect: Rect) -> Canvas
Canvas.func render<V: View>(_ view: V, in rect: Rect, _ ui: inout UI, background: RGB = UITheme.background)
Canvas.func scaled(_ scale: Int) -> Canvas
Canvas.func setPhysicalPixel(_ x: Int, _ y: Int, _ value: UInt32)
Canvas.func setPixel(_ x: Int, _ y: Int, _ value: UInt32)
Canvas.func smoothRect(_ rect: Rect, radius: Int, top: RGB, bottom: RGB)
Canvas.func text(_ line: TextLine, x: Int, y: Int, color: RGB, scale requested: Int = 1) -> Int
Canvas.func text(_ text: TextLine, x: Int, baseline: Int, face: FontFace, color: RGB) -> Int
Canvas.init(base: UInt64, pixelWidth: Int, pixelHeight: Int, stride: Int, shifts: UInt64, scale: Int)
Canvas.init(base: UInt64, width: Int, height: Int, stride: Int, shifts: UInt64)
Canvas.let base: UInt64
Canvas.let height: Int
Canvas.let pixelHeight: Int
Canvas.let pixelWidth: Int
Canvas.let scale: Int
Canvas.let stride: Int
Canvas.let width: Int
Canvas.static func textWidth(_ line: TextLine, scale: Int = 1) -> Int
Canvas.static func width(_ text: TextLine, face: FontFace) -> Int
Canvas.var shifts: UInt64
Chart.Plot.func index(at x: Int, count: Int, slots: Int) -> Int?
Chart.Plot.func x(of index: Int, count: Int, slots: Int) -> Double
Chart.Plot.func y(_ value: Double) -> Double
Chart.Plot.init(area: Rect, low: Double, high: Double)
Chart.Plot.var area: Rect
Chart.Plot.var high: Double
Chart.Plot.var low: Double
Chart.static func cursor(_ canvas: Canvas, _ plot: Plot, index: Int, count: Int, slots: Int, value: Double, colour: RGB)
Chart.static func dot(_ canvas: Canvas, x: Double, y: Double, radius: Double, colour: RGB)
Chart.static func endPoint(_ canvas: Canvas, _ plot: Plot, count: Int, slots: Int, colour: RGB, value: Double,
Chart.static func frame(_ canvas: Canvas, _ rect: Rect, low: Double, high: Double, lines: Int, labelWidth: Int,
Chart.static func niceTop(_ value: Double) -> Double
Chart.static func roundedPanel(_ canvas: Canvas, _ rect: Rect)
Chart.static func series(_ canvas: Canvas, _ plot: Plot, count: Int, slots: Int, colour: RGB, area: Bool,
Chart.static var background: RGB
Chart.static var bad: RGB
Chart.static var bright: RGB
Chart.static var cpu: RGB
Chart.static var grid: RGB
Chart.static var label: RGB
Chart.static var memory: RGB
Chart.static var realtime: RGB
Chart.static var write: RGB
Chart.struct Plot
DamageTracker.init()
DamageTracker.mutating func changes(_ canvas: Canvas, handle: UInt64, _ changed: (Rect) -> Void)
DamageTracker.static let tile
Divider.func draw(in rect: Rect, on canvas: Canvas, _ ui: inout UI)
Divider.func measure(_ proposal: Size) -> Size
Divider.init()
EditMenu.static func contains(_ id: Int) -> Bool
EditMenu.static let undo
FileLook.static func colour(_ name: Span<UInt8>) -> RGB
FileMenu.static func contains(_ id: Int) -> Bool
FileMenu.static let new
HStack.func draw(in rect: Rect, on canvas: Canvas, _ ui: inout UI)
HStack.func measure(_ proposal: Size) -> Size
HStack.init(spacing: Int = 8, @ViewBuilder _ content: () -> Content)
HStack.let content: Content
HStack.let spacing: Int
InputField.enum Change: Equatable
InputField.func contains(_ x: Int, _ y: Int) -> Bool
InputField.func withBytes<R>(_ body: (Span<UInt8>) -> R) -> R
InputField.init(maximumLength: Int = 512, secret: Bool = false)
InputField.mutating func clear()
InputField.mutating func command(_ id: Int) -> Change
InputField.mutating func draw(_ canvas: Canvas, _ rect: Rect, focused: Bool)
InputField.mutating func key(_ press: Keyboard.Result, _ keyboard: Keyboard) -> Change
InputField.mutating func pointer(_ x: Int, _ y: Int, down: Bool, pressed: Bool) -> Bool
InputField.mutating func select(from start: Int, to end: Int)
InputField.mutating func set(_ text: Span<UInt8>)
InputField.mutating func set(_ text: TextLine)
InputField.private(set) var anchor
InputField.private(set) var count
InputField.private(set) var cursor
InputField.private(set) var frame
InputField.static let capacity
InputField.var bordered
InputField.var cursorColour: RGB?
InputField.var face
InputField.var hasSelection: Bool
InputField.var isEmpty: Bool
InputField.var line: TextLine
InputField.var maximumLength: Int
InputField.var placeholder
InputField.var secret: Bool
InputField.var textColour
Keyboard.enum Result: Equatable
Keyboard.enum Special
Keyboard.init()
Keyboard.mutating func handle(code: UInt8, down: Bool) -> Result
Keyboard.private(set) var altGr
Keyboard.private(set) var command
Keyboard.private(set) var control
Keyboard.private(set) var option
Keyboard.private(set) var shift
Keyboard.static func utf8(_ code: UInt32, into out: inout InlineArray<4, UInt8>) -> Int
ListAnd.func compressible(_ index: Int) -> Bool
ListAnd.func draw(_ index: Int, in rect: Rect, on canvas: Canvas, _ ui: inout UI)
ListAnd.func flexible(_ index: Int) -> Bool
ListAnd.func measure(_ index: Int, _ proposal: Size) -> Size
ListAnd.let head: Head
ListAnd.let last: Last
ListAnd.var count: Int
ListBar.func draw(_ canvas: Canvas, offset: Int)
ListBar.init()
ListBar.mutating func beginFrame()
ListBar.mutating func place(_ area: Rect, total: Int, visible: Int) -> Int
ListBar.mutating func pointer(_ x: Int, _ y: Int, down: Bool, pressed: Bool, offset: Int) -> Int?
ListBar.private(set) var rect: Rect?
ListOf1.func compressible(_ index: Int) -> Bool
ListOf1.func draw(_ index: Int, in rect: Rect, on canvas: Canvas, _ ui: inout UI)
ListOf1.func flexible(_ index: Int) -> Bool
ListOf1.func measure(_ index: Int, _ proposal: Size) -> Size
ListOf1.let a: A
ListOf1.var count: Int
Padded.func draw(in rect: Rect, on canvas: Canvas, _ ui: inout UI)
Padded.func measure(_ proposal: Size) -> Size
Padded.init(_ amount: Int, @ViewBuilder _ content: () -> Content)
Padded.let amount: Int
Padded.let content: VStack<Content>
Padded.var flexible: Bool
ProgressBar.func draw(in rect: Rect, on canvas: Canvas, _ ui: inout UI)
ProgressBar.func measure(_ proposal: Size) -> Size
ProgressBar.let maximum: Int
ProgressBar.let value: Int
ProgressBar.var color: RGB
ProgressTask.let id: Int
RGB.func mixed(with other: RGB, _ amount: UInt32) -> RGB
RGB.init(_ red: UInt8, _ green: UInt8, _ blue: UInt8)
RGB.var red: UInt8, green: UInt8, blue: UInt8
Rect.init(x: Int, y: Int, width: Int, height: Int)
Rect.var bottom: Int
Rect.var right: Int
Rect.var x: Int, y: Int, width: Int, height: Int
ScrollBar.enum Part: Equatable
ScrollBar.static func draw(_ canvas: Canvas, _ rect: Rect, total: Int, visible: Int, offset: Int, active: Bool = false)
ScrollBar.static func needed(total: Int, visible: Int) -> Bool
ScrollBar.static func offset(after part: Part, offset: Int, total: Int, visible: Int, step: Int) -> Int
ScrollBar.static func offset(dragTo y: Int, grab: Int, _ rect: Rect, total: Int, visible: Int) -> Int
ScrollBar.static func part(at y: Int, _ rect: Rect, total: Int, visible: Int, offset: Int) -> Part?
ScrollBar.static func thumb(_ rect: Rect, total: Int, visible: Int, offset: Int) -> Rect
ScrollBar.static let width
Size.init(width: Int, height: Int)
Size.var width: Int, height: Int
Spacer.func draw(in rect: Rect, on canvas: Canvas, _ ui: inout UI)
Spacer.func measure(_ proposal: Size) -> Size
Spacer.init()
Spacer.var flexible: Bool
Surface.func addEditMenu(_ index: Int, contextMenu: Bool = true)
Surface.func addFileMenu(_ index: Int = 0, new: StaticString = "", open: Bool = false, save: Bool = false, saveAs: Bool = false,
Surface.func addItem(_ index: Int, _ title: StaticString, id: Int, key: UInt8 = 0, enabled: Bool = true, icon: MenuIcon = .none,
Surface.func addMenu(_ index: Int, _ title: StaticString)
Surface.func addSeparator(_ index: Int)
Surface.func beginDrawing()
Surface.func carry()
Surface.func clearMenus()
Surface.func destroy()
Surface.func isCancelled(_ task: ProgressTask) -> Bool
Surface.func present(_ rect: Rect) -> Bool
Surface.func presentChanges()
Surface.func progress(_ task: ProgressTask, done: UInt64)
Surface.func progress(_ task: ProgressTask, finished end: ProgressEnd, done: UInt64? = nil)
Surface.func progress(_ title: TextLine, total: UInt64, unit: ProgressUnit = .none, cancellable: Bool = false) -> ProgressTask?
Surface.func publishMenus()
Surface.func raise()
Surface.func requestSize(width: Int, height: Int)
Surface.func setItem(_ id: Int, enabled: Bool)
Surface.func setItem(_ id: Int, on: Bool)
Surface.func setTitle(_ text: TextLine)
Surface.func wait(timeout: UInt64)
Surface.let handle: UInt64
Surface.mutating func nextEvent() -> SurfaceEvent?
Surface.mutating func setPointer(_ shape: PointerShape)
Surface.private(set) var canvas: Canvas
Surface.static func create(timeout: UInt64 = 10_000_000_000) -> Surface?
Surface.static let cancelRequests
Surface.static let frameCounter
Surface.static let frameShown
SurfaceMessage.static func field(_ message: InlineArray<256, UInt8>, _ index: Int) -> UInt32
SurfaceMessage.static func make(_ kind: UInt8, _ fields: InlineArray<4, UInt32>, count: Int) -> (InlineArray<17, UInt8>, Int)
SurfaceMessage.static let carry: UInt8
SurfaceMessage.static let close: UInt8
SurfaceMessage.static let configure: UInt8
SurfaceMessage.static let contextMenu: UInt8
SurfaceMessage.static let contextMenuIndex
SurfaceMessage.static let disabled: UInt8
SurfaceMessage.static let dropped: UInt8
SurfaceMessage.static let focus: UInt8
SurfaceMessage.static let key: UInt8
SurfaceMessage.static let menu: UInt8
SurfaceMessage.static let menuChosen: UInt8
SurfaceMessage.static let menuEnabled: UInt8
SurfaceMessage.static let menuItem: UInt8
SurfaceMessage.static let menuReset: UInt8
SurfaceMessage.static let menuState: UInt8
SurfaceMessage.static let on: UInt8
SurfaceMessage.static let pointer: UInt8
SurfaceMessage.static let pointerShape: UInt8
SurfaceMessage.static let present: UInt8
SurfaceMessage.static let progress: UInt8
SurfaceMessage.static let raise: UInt8
SurfaceMessage.static let scroll: UInt8
SurfaceMessage.static let separator: UInt8
SurfaceMessage.static let size: UInt8
SurfaceMessage.static let title: UInt8
SurfaceMessage.static let toggle: UInt8
Text.func draw(in rect: Rect, on canvas: Canvas, _ ui: inout UI)
Text.func measure(_ proposal: Size) -> Size
Text.init(_ text: StaticString, face: FontFace = .body, color: RGB = UITheme.text)
Text.init(_ text: TextLine, face: FontFace = .body, color: RGB = UITheme.text)
Text.let text: TextLine
Text.var color: RGB
Text.var compressible: Bool
Text.var face: FontFace
UI.func button(at x: Int, _ y: Int) -> Int
UI.init()
UI.mutating func addButton(_ id: Int, _ rect: Rect)
UI.mutating func beginFrame()
UI.mutating func button(_ canvas: Canvas, _ rect: Rect, id: Int, _ title: TextLine, kind: ButtonKind = .secondary,
UI.mutating func key(_ press: Keyboard.Result, shift: Bool) -> Int
UI.var focused
UI.var pressed
UIDesign.var accent: RGB
UIDesign.var accentPressed: RGB
UIDesign.var blue: RGB
UIDesign.var chart: RGB
UIDesign.var chartBright: RGB
UIDesign.var chartGrid: RGB
UIDesign.var chartLabel: RGB
UIDesign.var danger: RGB
UIDesign.var faint: RGB
UIDesign.var good: RGB
UIDesign.var ground: RGB
UIDesign.var light: Bool
UIDesign.var line: RGB
UIDesign.var muted: RGB
UIDesign.var onAccent: RGB
UIDesign.var raised: RGB
UIDesign.var selection: RGB
UIDesign.var selectionText: RGB
UIDesign.var surface: RGB
UIDesign.var text: RGB
UIDesign.var violet: RGB
UITheme.nonisolated(unsafe) private(set) static var palette
UITheme.static func use(light: Bool)
UITheme.static let dark
UITheme.static let light
UITheme.static var accent: RGB
UITheme.static var accentPressed: RGB
UITheme.static var background: RGB
UITheme.static var chart: RGB
UITheme.static var codeComment: RGB
UITheme.static var codeKeyword: RGB
UITheme.static var codeShape: RGB
UITheme.static var codeValue: RGB
UITheme.static var danger: RGB
UITheme.static var faint: RGB
UITheme.static var good: RGB
UITheme.static var ground: RGB
UITheme.static var isLight: Bool
UITheme.static var line: RGB
UITheme.static var muted: RGB
UITheme.static var onAccent: RGB
UITheme.static var raised: RGB
UITheme.static var selection: RGB
UITheme.static var selectionText: RGB
UITheme.static var text: RGB
UITheme.static var warning: RGB
VStack.func draw(in rect: Rect, on canvas: Canvas, _ ui: inout UI)
VStack.func measure(_ proposal: Size) -> Size
VStack.init(spacing: Int = 8, @ViewBuilder _ content: () -> Content)
VStack.init(spacing: Int, content: Content)
VStack.let content: Content
VStack.let spacing: Int
VStack.var flexible: Bool
View.var compressible: Bool
View.var flexible: Bool
ViewBuilder.static func buildExpression<V: View>(_ view: V) -> V
ViewBuilder.static func buildPartialBlock<A: View>(first: A) -> ListOf1<A>
ViewBuilder.static func buildPartialBlock<Head: ViewList, Last: View>(accumulated: Head, next: Last) -> ListAnd<Head, Last>
enum ButtonKind: Sendable
enum ButtonLook
enum ButtonSize: Sendable
enum ButtonSymbol: Sendable
enum Chart
enum EditMenu
enum FileLook
enum FileMenu
enum FontFace
enum MenuIcon: UInt8
enum PointerShape: UInt8
enum ProgressEnd: UInt8, Sendable
enum ProgressUnit: UInt8, Sendable
enum ScrollBar
enum SurfaceEvent
enum SurfaceMessage
enum UITheme
enum ViewBuilder
protocol View
protocol ViewList
struct Button: View
struct ButtonState: Sendable
struct Canvas
struct DamageTracker
struct Divider: View
struct HStack<Content: ViewList>: View
struct InputField
struct Keyboard
struct ListAnd<Head: ViewList, Last: View>: ViewList
struct ListBar
struct ListOf1<A: View>: ViewList
struct Padded<Content: ViewList>: View
struct ProgressBar: View
struct ProgressTask: Equatable, Sendable
struct RGB: Equatable, Sendable
struct Rect: Equatable
struct Size: Equatable, Sendable
struct Spacer: View
struct Surface
struct Text: View
struct UI
struct UIDesign: Sendable
struct VStack<Content: ViewList>: View

sound · Abspielen und Hören

Abspielen (sound.play): jedes Programm bekommt einen Ring, den der Mischer des Kerns spielt (48 kHz, Stereo, Int16). Hören (sound.microphone): der Kern schreibt, was ein Mikrofon hört, in einen Ring pro Mikrofon (48 kHz, 16 Bit, mono/stereo, etwa 1,4 s), lesend in jedes hörende Programm eingeblendet; der Pegel jeder 10-ms-Periode steht daneben. Das Mikrofon läuft nur, solange jemand hört; die rote MIC-Anzeige nennt jedes Programm, und der Besitzer kann alle stoppen. Die Werkzeuge (Pegel, Auto-Pegel, Rauschtor, Stimmerkennung, Schnitt) kommen mit uses-heap und stehen unter Bibliotheken › sound.

Teile nur für Systemprogramme: System-API › sound.

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
sound.playTon abspielen: ein Ring, den der Mischer des Kerns spielt.≤ 1 mssound.open0x0030_0006
sound.microphoneMikrofon hören; die rote MIC-Anzeige nennt jedes Programm, das hört.≤ 1 msmicrophone.open0x0031_0002

SystemaufrufesoundModul 0x0030 · Ton über den Mischer des Systems (sound.play; tone/play/stop geplant).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
sound.toneTone → Playedkeins · rechnet Reflex im Programm≤ 20 µs0x0030_0001
sound.playPlay → Playedkeins · vom Kern noch nicht bedient≤ 100 µs0x0030_0002
sound.stopStopSound → Donekeins · vom Kern noch nicht bedient≤ 20 µs0x0030_0003
sound.Tone effectReflex-EffektEffekt0x0030_0004
sound.Play effectReflex-EffektEffekt0x0030_0005
sound.openSoundQuery → SoundRingsound.play≤ 1 ms0x0030_0006
sound.closeSoundQuery → Donekeins≤ 5 µs0x0030_0007
sound.statusSoundQuery → SoundStatuskeins≤ 5 µs0x0030_0008

SystemaufrufemicrophoneModul 0x0031 · Die Mikrofone des Roboters (sound.microphone, sound.microphone.provide).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
microphone.listMicrophoneListRequest → MicrophoneListsound.microphone oder sound.microphone.provide≤ 20 µs0x0031_0001
microphone.openMicrophoneQuery → MicrophoneMapsound.microphone≤ 1 ms0x0031_0002
microphone.closeMicrophoneQuery → Donesound.microphone≤ 1 ms0x0031_0003
microphone.loud eventLoudnessReflex-EreignisEreignis0x0031_0008
microphone.voice eventVoiceChangeReflex-EreignisEreignis0x0031_0009

SystemaufrufesignalModul 0x0040 · Messwerte über die Zeit: Spektrum, Filter, Statistik.

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
signal.spectrumSpectrumRequest → Spectrumkeins · rechnet Reflex im Programm≤ 500 µs0x0040_0001
signal.filterFilterRequest → Sampleskeins · rechnet Reflex im Programm≤ 200 µs0x0040_0002
signal.statsSamples → Statskeins · rechnet Reflex im Programm≤ 50 µs0x0040_0003
signal.sineSineRequest → Sampleskeins · rechnet Reflex im Programm≤ 2 ms0x0040_0004

SwiftSound.OutputAbspielen

AufrufWas er tutShape-Aufruf · Zeitbudget
Öffnen
Sound.Output.open() -> Sound.Output?staticDer Ring des Programms (bei jedem Aufruf derselbe); nil ohne sound.play oder Tongerät.≤ 1 mssound.open0x0030_0006
Beispiel
if output == nil { output = Sound.Output.open() }
aus apps/sound (gekürzt)
Abspielen
Sound.Output.write(_ frames: UnsafePointer<Int16>, count: Int) -> IntSchreibt bis zu count Frames (links, rechts); gibt zurück, wie viele passten.
Beispiel
_ = chunk.withUnsafeBufferPointer { output.write($0.baseAddress!, count: count) }
aus apps/sound (gekürzt)
Sound.Output.room / .queued / .withDevice: IntPlatz jetzt / geschrieben, nicht gespielt / beim Gerät, noch nicht gehört.
Beispiel
while output.room >= 480 && position < total { /* nachfüllen */ }
aus apps/sound (gekürzt)
Sound.Output.flush()Verwirft das Wartende (Stopp).
Beispiel
output?.flush()   // Stopp: Wartendes verwerfen
aus apps/sound (gekürzt)
Lautstärke
Sound.Output.volume: IntEigene Lautstärke 0 … 100 (über der Gesamtlautstärke).
Sound.Output.status: (volume: Int, device: Bool, playing: Bool)staticGesamtlautstärke, Gerät vorhanden, spielt gerade.≤ 5 µssound.status0x0030_0008
Beispiel
let hasDevice = Sound.Output.status.device
aus apps/settings (gekürzt)
Schließen
Sound.Output.close()Ring wird nicht mehr gemischt.≤ 5 µssound.close0x0030_0007
Konstanten
Sound.Output.rate = 48_000 / .capacity: IntstaticAbtastrate / Größe des Rings.

SwiftSound.Microphone · Sound.MicrophoneRing · Sound.MicrophoneInfoHören

AufrufWas er tutShape-Aufruf · Zeitbudget
Mikrofon wählen & öffnen
Sound.Microphone.info(at index: Int) -> Sound.MicrophoneInfo?Das index-te Mikrofon (name, rate, channels, listening, id).≤ 20 µsmicrophone.list0x0031_0001
Beispiel
guard let info = Sound.Microphone.info(at: 0) else { problem = TextLine("There is no microphone."); return true }
aus apps/sound (gekürzt)
Sound.Microphone.open(_ id: Int? = nil) -> Sound.MicrophoneRing?Hören beginnen (nil: das erste Mikrofon); startet das Mikrofon.≤ 1 msmicrophone.open0x0031_0002
Beispiel
guard let opened = Sound.Microphone.open(info.id) else { return true }
ring = opened
ring?.skipToNow()
aus apps/sound (gekürzt)
Sound.Microphone.close(_ id: Int? = nil) -> BoolAufhören; das Mikrofon stoppt, wenn niemand mehr hört.≤ 1 msmicrophone.close0x0031_0003
Beispiel
Sound.Microphone.close()
aus apps/sound (gekürzt)
Proben lesen
Sound.MicrophoneRing.read(into: UnsafeMutablePointer<Int16>, frames: Int) -> (frames: Int, lost: Int)Wartende Frames kopieren; wer mehr als den Ring zurück ist, springt zur neuesten Sekunde (lost).
Beispiel
let got = raw.withUnsafeMutableBufferPointer { ring!.read(into: $0.baseAddress!, frames: 4800) }
aus apps/sound (gekürzt)
Sound.MicrophoneRing.skipToNow()Wartendes überspringen.
Zustand & Pegel
Sound.MicrophoneRing.state: State (running, idle, stoppedByOwner, failed)Was das Mikrofon tut – z. B. vom Besitzer gestoppt.
Beispiel
if let state = ring?.state, state == .stoppedByOwner { problem = TextLine("You stopped the microphone (MIC in the menu bar).") }
aus apps/sound (gekürzt)
Sound.MicrophoneRing.peakDecibels / .rmsDecibels / .periods / .available / .rate / .channels / .ringFramesPegel der letzten 10 ms (dBFS), Zähler, Wartendes.
Beispiel: Mikrofon öffnen und lesen (apps/sound, Capture.swift)
// manifest: capabilities = …, sound.play, sound.microphone   (+ uses-heap)
guard let info = Sound.Microphone.info(at: 0) else {
    problem = TextLine("There is no microphone.")
    return true
}
guard let opened = Sound.Microphone.open(info.id) else { return true }
ring = opened
ring?.skipToNow()
autoLevel = AutoLevel(channels: channels, gain: Double(choices.gain))
gate = NoiseGate(channels: channels)
voice = VoiceDetector(channels: channels)

// in der Schleife:
if ring!.state == .stoppedByOwner { problem = TextLine("You stopped the microphone (MIC in the menu bar).") }
while true {
    let got = raw.withUnsafeMutableBufferPointer { ring!.read(into: $0.baseAddress!, frames: 4800) }
    guard got.frames > 0 else { break }
    // ... in 10-ms-Perioden: autoLevel.process(&span), gate.process(&span),
    //     LevelMeter.measure(span), voice.detect(span)
}

// beim Ende:
Sound.Microphone.close()
Beispiel: Abspielen über den Mischer (apps/sound, Player.swift, gekürzt)
if output == nil { output = Sound.Output.open() }
guard let output else { return }
while output.room >= 480 && position < total {
    let count = min(output.room, 4800, total - position)
    // chunk mit count Stereo-Frames füllen (links, rechts)
    _ = chunk.withUnsafeBufferPointer { output.write($0.baseAddress!, count: count) }
    position += count
}
// Stopp: output.flush()
Alle 38 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
Sound.Microphone.static func close(_ id: Int? = nil) -> Bool
Sound.Microphone.static func info(at index: Int) -> Sound.MicrophoneInfo?
Sound.Microphone.static func open(_ id: Int? = nil) -> Sound.MicrophoneRing?
Sound.MicrophoneInfo.init()
Sound.MicrophoneInfo.var channels
Sound.MicrophoneInfo.var id
Sound.MicrophoneInfo.var listening
Sound.MicrophoneInfo.var name
Sound.MicrophoneInfo.var nameLength
Sound.MicrophoneInfo.var rate
Sound.MicrophoneRing.enum State
Sound.MicrophoneRing.mutating func read(into: UnsafeMutablePointer<Int16>, frames: Int) -> (frames: Int, lost: Int)
Sound.MicrophoneRing.mutating func skipToNow()
Sound.MicrophoneRing.private(set) var position: UInt32
Sound.MicrophoneRing.var available: Int
Sound.MicrophoneRing.var channels: Int
Sound.MicrophoneRing.var peakDecibels: Float
Sound.MicrophoneRing.var periods: UInt32
Sound.MicrophoneRing.var rate: Int
Sound.MicrophoneRing.var ringFrames: Int
Sound.MicrophoneRing.var rmsDecibels: Float
Sound.MicrophoneRing.var state: State
Sound.Output.func close()
Sound.Output.func flush()
Sound.Output.func write(_ frames: UnsafePointer<Int16>, count: Int) -> Int
Sound.Output.let capacity: Int
Sound.Output.static func open() -> Sound.Output?
Sound.Output.static let rate
Sound.Output.static var status: (volume: Int, device: Bool, playing: Bool)
Sound.Output.var queued: Int
Sound.Output.var room: Int
Sound.Output.var volume: Int
Sound.Output.var withDevice: Int
Sound.enum Microphone
Sound.struct MicrophoneInfo
Sound.struct MicrophoneRing
Sound.struct Output
enum Sound

camera · Kameras, Sehen und Erkennungen

Bilder kommen aus den Ringen des Kerns: mit camera.use wird der Bildring einer Kamera lesend ins Programm eingeblendet (neuestes Bild ohne Systemaufruf); Anbieter (camera.provide: Test-Kamera, USB-Treiber) schieben JPEG-Bilder hinein. Die Mac-Kamera nimmt nur auf, solange ein Programm den Ring offen hat.

Erkennung läuft im Programm Camera (lokales Modell, keine Netzverbindung). Es veröffentlicht seine Treffer im Ring camera.detections (publish = detections); Roboterprogramme abonnieren ihn mit subscribe = camera.detections und lesen ohne Systemaufruf und ohne Warten – auch in einer Echtzeit-Schleife. Zu alte Bilder werden verworfen („stale pictures must not steer a robot“).

Teile nur für Systemprogramme: System-API › camera.

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
camera.useKameras auflisten und ihre Bildringe lesend einblenden.≤ 1 mscamera.ring0x0020_0006

SystemaufrufecameraModul 0x0020 · Die Kameras des Roboters (camera.use, camera.provide).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
camera.listCameraListRequest → CameraListcamera.use oder camera.provide≤ 20 µs0x0020_0001
camera.frameFrameRequest → CameraFramecamera.use≤ 10 µs0x0020_0002
camera.toWorldPixelPoint → WorldPointcamera.use · rechnet Reflex im Programm≤ 2 µs0x0020_0003
camera.fromWorldWorldPoint → PixelPointcamera.use · rechnet Reflex im Programm≤ 2 µs0x0020_0004
camera.frame eventCameraFrameReflex-EreignisEreignis0x0020_0005
camera.ringCameraRingQuery → CameraRingMapcamera.use≤ 1 ms0x0020_0006
camera.closeCameraRingQuery → Donecamera.use≤ 1 ms0x0020_0009

SystemaufrufevisionModul 0x0021 · Was die Kameras sehen: Erkennungen, Farbmasken, Bewegung, Marker.

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
vision.detectionsDetectionFilter → Detectionskeins · rechnet Reflex im Programm≤ 10 µs0x0021_0001
vision.maskColorMask → Maskkeins · rechnet Reflex im Programm≤ 2 ms0x0021_0002
vision.motionMotionRequest → Motion2Dkeins · rechnet Reflex im Programm≤ 1 ms0x0021_0003
vision.markersMarkerRequest → Markerskeins · rechnet Reflex im Programm≤ 3 ms0x0021_0004
vision.detections eventDetectionsReflex-EreignisEreignis0x0021_0005

SwiftCamera · CameraInfo · CameraRingKamera wählen, öffnen, Bilder lesen

AufrufWas er tutShape-Aufruf · Zeitbudget
Kamera wählen & öffnen
Camera.info(at index: Int) -> CameraInfo?Die index-te Kamera (name, width, height, frames, running, id).≤ 20 µscamera.list0x0020_0001
Beispiel
while let info = Camera.info(at: index) { list.append(info); index += 1 }
aus apps/video (gekürzt)
Camera.open(_ id: Int) -> CameraRing?Bildring einblenden; startet die Aufnahme.≤ 1 mscamera.ring0x0020_0006
Beispiel
if ring == nil, let info = Camera.info(at: 0) { ring = Camera.open(info.id) }
aus apps/server (gekürzt)
Camera.close(_ id: Int) -> BoolRing ausblenden; die Mac-Kamera stoppt, wenn ihn niemand mehr hat.≤ 1 mscamera.close0x0020_0009
Beispiel
Camera.close(cameras[chosenCamera].id)
aus apps/video (gekürzt)
Bilder lesen
CameraRing.newest(after: UInt32, into buffer: UnsafeMutableRawBufferPointer) -> (frame: UInt32, count: Int, time: UInt64)?Kopiert das neueste Bild (JPEG), wenn es neuer als after ist: Nummer, Größe, Aufnahmezeit.
Beispiel
let taken = jpeg.withUnsafeMutableBytes { ring.newest(after: frame.number, into: $0) }
aus apps/video (gekürzt)
CameraRing.latest / .width / .height / .runningNeuestes vollständiges Bild, Maße, läuft die Kamera?

SwiftDetectionReaderErkennungen lesen (Abonnent)

AufrufWas er tutShape-Aufruf · Zeitbudget
Lesen
DetectionReader.newest(after: UInt32 = 0, now: UInt64, maximumAge: UInt64) -> DetectionBatch?Neuester Stapel, außer er ist älter als maximumAge ns.
Beispiel
if let batch = ring.newest(after: last, now: before, maximumAge: maximumAge) { last = batch.number }
aus apps/rtvision (gekürzt)
Klassen & Modell
DetectionReader.classIndex(of name: StaticString) -> Int? / .classByte(_:_:) / .classCountKlasse über den Namen finden, Namen lesen.
Beispiel
if let cup = ring.classIndex(of: "cup"), let best = batch.best(of: cup) { aim(best.centreX, best.centreY) }
Muster (kurz, nicht aus einem Programm kopiert)
DetectionReader.latest / .modelGeneration / .modelNameNeueste Stapelnummer; Generation steigt bei Modellwechsel (Klassen neu suchen).

SwiftDetectionWriterErkennungen veröffentlichen (Video)

AufrufWas er tutShape-Aufruf · Zeitbudget
Klassen & Modell
DetectionWriter.setClassName(_ index: Int, length: Int, _ byteAt: (Int) -> UInt8) / .classesDone(count: Int)Klassennamen einmal schreiben.
Beispiel
publisher?.setClassName(classIndex, length: name.count) { name[$0] }
publisher?.classesDone(count: model.classNames.count)
aus apps/video (gekürzt)
DetectionWriter.setModel(length: Int, _ byteAt: (Int) -> UInt8)Name des aktiven Modells (Generation steigt).
Schreiben
DetectionWriter.publish(_ batch: DetectionBatch) -> UInt32Stapel als nächsten schreiben; seine Nummer.
Beispiel
publisher!.publish(batch)
aus apps/video (gekürzt)
DetectionWriter.readers: IntWie viele Programme gerade lesen.

SwiftDetectionBatch · Sighting · DetectionRingEin Stapel Erkennungen

AufrufWas er tutShape-Aufruf · Zeitbudget
Stapel
DetectionBatch.number, .frame, .captured, .done, .width, .height, .count, .objects (bis 32)Was ein Bild zeigte.
DetectionBatch.best(of classIndex: Int) -> Sighting?Bester Treffer einer Klasse.
Objekt
Sighting(classIndex: Int, score: Double, x0: Double, y0: Double, x1: Double, y1: Double)Ein Objekt: Klasse, Sicherheit, Kasten als Bruchteile des Bildes.
Beispiel
batch.objects[batch.count] = Sighting(classIndex: detection.classIndex, score: Double(detection.score),
                                      x0: x0, y0: y0, x1: x1, y1: y1)
batch.count += 1
aus apps/video (gekürzt)
Sighting.centreX / .centreYMitte des Kastens.
Ring-Format
DetectionRing.format(_:) / .magic / .version / .OffsetsAufbau des Rings (eine 16-KiB-Seite).

Für Reflex-SkripteShape-Aufrufe, die Reflex-Skripte direkt beim Namen rufen

AufrufWas er tutShape-Aufruf · Zeitbudget
Für Reflex und den Kern
vision.detectionsNeueste Erkennungen (Ring von Video).≤ 10 µsvision.detections0x0021_0001
vision.mask / vision.motion / vision.markersFarbmaske mit Flecken, Bewegung zwischen zwei Bildern, AprilTag-Marker.≤ 2 msvision.mask0x0021_0002
camera.frame / camera.toWorld / camera.fromWorldNeuestes Bild; Bild- ↔ Weltkoordinaten (Kalibrierung nötig).≤ 2 µscamera.toWorld0x0020_0003
Beispiel: Neuestes Kamerabild holen und dekodieren (apps/video, Pipeline.swift)
// manifest: capabilities = …, camera.use   publish = detections
var list: [CameraInfo] = []
var index = 0
while let info = Camera.info(at: index) { list.append(info); index += 1 }
ring = Camera.open(list[0].id)

func takeFrame() -> Bool {
    guard let ring else { return false }
    let taken = jpeg.withUnsafeMutableBytes { ring.newest(after: frame.number, into: $0) }
    guard let taken else { return false }
    guard case .success(let picture) = Picture.decode(Array(jpeg[0..<taken.count])) else { return false }
    // ... erkennen, zeichnen
    return true
}
Beispiel: Erkennungen veröffentlichen (apps/video)
nonisolated(unsafe) var publisher = Publications.detections()

var batch = DetectionBatch()
batch.frame = shown.number
batch.captured = shown.captured
batch.done = done
batch.width = width; batch.height = height
batch.objects[batch.count] = Sighting(classIndex: 3, score: 0.82, x0: 0.1, y0: 0.2, x1: 0.4, y1: 0.6)
batch.count += 1
publisher!.publish(batch)
Beispiel: Erkennungen in einer 1-kHz-Schleife lesen (apps/rtvision)
// manifest: realtime = 1000 200 log
//           subscribe = camera.detections
guard let ring = Publications.subscription(0) else {
    System.log("rtvision: no subscription (subscribe line missing)")
    return
}
var last: UInt32 = 0
while true {
    let now = System.time
    if let batch = ring.newest(after: last, now: now, maximumAge: 5_000_000_000) {
        last = batch.number
        // batch.objects[0..<batch.count], ring.classByte(classIndex, at) für den Namen
    }
    System.waitForNextPeriod()
}
Alle 67 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
Camera.static func close(_ id: Int) -> Bool
Camera.static func info(at index: Int) -> CameraInfo?
Camera.static func open(_ id: Int) -> CameraRing?
CameraInfo.init()
CameraInfo.var frames: UInt32
CameraInfo.var id
CameraInfo.var name
CameraInfo.var nameLength
CameraInfo.var running
CameraInfo.var width
CameraRing.func newest(after: UInt32, into buffer: UnsafeMutableRawBufferPointer) -> (frame: UInt32, count: Int, time: UInt64)?
CameraRing.var height: Int
CameraRing.var latest: UInt32
CameraRing.var running: Bool
CameraRing.var width: Int
DetectionBatch.func best(of classIndex: Int) -> Sighting?
DetectionBatch.init()
DetectionBatch.static let most
DetectionBatch.var captured: UInt64
DetectionBatch.var count
DetectionBatch.var done: UInt64
DetectionBatch.var frame: UInt32
DetectionBatch.var number: UInt32
DetectionBatch.var objects
DetectionBatch.var width
DetectionReader.func classByte(_ index: Int, _ at: Int) -> UInt8
DetectionReader.func classIndex(of name: StaticString) -> Int?
DetectionReader.func newest(after: UInt32 = 0, now: UInt64, maximumAge: UInt64) -> DetectionBatch?
DetectionReader.init?(_ memory: M)
DetectionReader.let memory: M
DetectionReader.var classCount: Int
DetectionReader.var latest: UInt32
DetectionReader.var modelGeneration: UInt32
DetectionReader.var modelName: (bytes: InlineArray<24, UInt8>, length: Int)
DetectionRing.static func format<M: SharedWords>(_ memory: M)
DetectionRing.static let batchBytes
DetectionRing.static let batches
DetectionRing.static let batchesOffset
DetectionRing.static let bytes
DetectionRing.static let magic: UInt32
DetectionRing.static let modelGenerationOffset
DetectionRing.static let modelNameBytes
DetectionRing.static let modelNameOffset
DetectionRing.static let mostClasses
DetectionRing.static let nameBytes
DetectionRing.static let namesOffset
DetectionRing.static let readersOffset
DetectionRing.static let version: UInt32
DetectionWriter.func classesDone(count: Int)
DetectionWriter.func setClassName(_ index: Int, length: Int, _ byteAt: (Int) -> UInt8)
DetectionWriter.func setModel(length: Int, _ byteAt: (Int) -> UInt8)
DetectionWriter.init?(_ memory: M)
DetectionWriter.let memory: M
DetectionWriter.mutating func publish(_ batch: DetectionBatch) -> UInt32
DetectionWriter.var readers: Int
Sighting.init()
Sighting.init(classIndex: Int, score: Double, x0: Double, y0: Double, x1: Double, y1: Double)
Sighting.var centreX: Double
Sighting.var centreY: Double
enum Camera
enum DetectionRing
protocol SharedWords
struct CameraInfo
struct CameraRing
struct DetectionBatch
struct DetectionReader<M: SharedWords>
struct DetectionWriter<M: SharedWords>

robot · Arme, Kinematik, Aktor-Dienst, CAN

Bewegungen sind Effekte: Programme bewegen nie selbst Motoren, sondern bitten den Aktor-Dienst (actuators, Recht safety.actuator) über den Kanal actuator (Recht channels.ipc). Der Dienst prüft jede Bewegung gegen die Sicherheitsgrenzen (begrenzt oder lehnt ab) und spricht über CAN mit den Motoren. Der Not-Halt hält der Kern selbst: jedes Programm darf ihn lesen, auslösen und lösen nur mit safety.stop. Programme sehen eine Generation, die sich mit jedem Halt und jeder Freigabe ändert (ungerade = gehalten).

Für Arme gibt es Modelle (SR-6, SO-101, UR5e, UR3e, FR3, xArm6, myCobot 280) mit Vorwärts- und Rückwärtskinematik, eine simulierte Greiferkamera und simulierte Motoren; der Aktor-Dienst veröffentlicht den Arm-Zustand (publish = arm).

Teile nur für Systemprogramme: System-API › robot.

Rechte

Kein eigenes Recht: Programme bewegen den Arm über den Kanal actuator zum Aktor-Dienst (channels.ipc) und lesen seinen Zustand als Veröffentlichung (subscribe = …).

SystemaufruferobotModul 0x0101 · Gelenke bewegen; Sicherheitsgrenzen und Not-Halt gelten immer.

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
robot.moveMove → Motionkeins · rechnet Reflex im Programm≤ 20 µs0x0101_0001
robot.stateJointQuery → JointStatekeins · rechnet Reflex im Programm≤ 5 µs0x0101_0002
robot.Move effectReflex-EffektEffekt0x0101_0003
robot.moved eventMotionReflex-EreignisEreignis0x0101_0004

SystemaufrufearmModul 0x0102 · Der Arm als Ganzes: Vorwärts-/Rückwärtskinematik, Gelenke, Drehmoment.

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
arm.forwardAngles → ToolPosekeins · rechnet Reflex im Programm≤ 2 µs0x0102_0001
arm.inverseReach → Angleskeins · rechnet Reflex im Programm≤ 20 µs0x0102_0002
arm.jointsJointsRequest → JointListkeins · rechnet Reflex im Programm≤ 10 µs0x0102_0003
arm.torqueTorqueCommand → Donekeins · vom Kern noch nicht bedient≤ 1 µs0x0102_0004
arm.TorqueCommand effectReflex-EffektEffekt0x0102_0005

SwiftArmModelEin Arm: Gelenke, Reichweite, Werkzeug

AufrufWas er tutShape-Aufruf · Zeitbudget
Arm wählen
ArmModel.sr6 / .model(_ index: Int) -> ArmModelstaticDer simulierte Tischarm / Modell nach Index.
ArmModel.ids: InlineArray<7, StaticString>static"sr6", "so101", "ur5e", "ur3e", "fr3", "xarm6", "mycobot280".
ArmModel.chosen<let n: Int>(_ id: InlineArray<n, UInt8>, count: Int) -> ArmModel / .index(of:count:)staticArm nach den Bytes von arm = (Settings › Robot); SR-6 wenn leer.
Beispiel
let model = ArmModel.chosen(state.id, count: state.idLength)
aus apps/server (gekürzt)
Kinematik
ArmModel.forward(_ q: ArmAngles) -> ArmPoseGelenkwinkel → Punkte des Arms und Werkzeugpose.≤ 2 µsarm.forward0x0102_0001
Beispiel
let pose = model.forward(q)   // pose.tip: ArmPoint in mm
Muster (kurz, nicht aus einem Programm kopiert)
ArmModel.inverse(x: Double, y: Double, z: Double, pitch: Double, near: ArmAngles) -> ArmAngles?Werkzeugspitze nach (x, y, z) mit Neigung, am nächsten zu near; nil außer Reichweite.≤ 20 µsarm.inverse0x0102_0002
Beispiel
if let q = model.inverse(x: 300, y: 0, z: 120, pitch: -Maths.pi / 2, near: current) { goTo(q) }
Muster (kurz, nicht aus einem Programm kopiert)
Gelenke & Daten
ArmModel.joint(_ index: Int) -> ArmJoint / .count / .jointsGelenke (name, low, high, fastest, strongest, rest).≤ 10 µsarm.joints0x0102_0003
ArmModel.name, .maker, .id, .reach, .payload, .tool, .restAngles, .closedForm, .urdf …Beschreibung des Arms.

SwiftArmAngles · ArmPoint · ArmPose · ArmCameraWinkel, Punkte, Posen, Greiferkamera

AufrufWas er tutShape-Aufruf · Zeitbudget
ArmAngles · ArmPoint · ArmPose · ArmCamera
ArmAngles() / .subscript(_ index: Int) -> DoubleGelenkwinkel in Radiant (bis 7).
Beispiel
var angles = ArmAngles()
angles[joint] = Double(state.positions[joint]) / 100 * Double.pi / 180
aus apps/server (gekürzt)
ArmPoint(_ x: Double = 0, _ y: Double = 0, _ z: Double = 0)Punkt in Welt-mm (x vor, y links, z hoch).
ArmPose.points, .pointCount, .tip, .approach, .pitchWo der Arm ist.
ArmCamera(_ model: ArmModel, _ q: ArmAngles): toWorld(x:y:depth:) / .fromWorld(_:)Greiferkamera 640 × 480: Pixel ↔ Weltpunkt.≤ 2 µscamera.toWorld0x0020_0003

SwiftSimulatedMotorsDie simulierten Motoren (Aktor-Dienst)

AufrufWas er tutShape-Aufruf · Zeitbudget
Anlegen
SimulatedMotors(_ model: ArmModel = .sr6)Arm in Ruhestellung.
Beispiel
motors = SimulatedMotors(model)
aus apps/actuators (gekürzt)
Steuern
SimulatedMotors.set(joint: Int, target value: Int32, speed limit: Int32)Sollwert in 0,01° und Geschwindigkeit.
Beispiel
motors.set(joint: jointNumber - 1, target: grantedTarget, speed: grantedSpeed)
aus apps/actuators (gekürzt)
SimulatedMotors.step(milliseconds: Int) / .emergencyStop(_ on: Bool)Bewegung simulieren / sofort bremsen.
Zustand
SimulatedMotors.moving / .position / .velocity / .target / .speed / .stoppedZustand.

SwiftArmRing · ArmStateArm-Zustand ohne Systemaufruf lesen

AufrufWas er tutShape-Aufruf · Zeitbudget
Lesen
ArmRing.read<Ring: SharedWords>(_ ring: Ring) -> ArmState?Neuester vollständiger Zustand (Abo subscribe = actuators.arm).
Beispiel
guard let ring = Publications.subscriptionRing(0), let state = ArmRing.read(ring) else { return page }
aus apps/server (gekürzt)
ArmState.positions, .moving, .stopped, .chosen, .id, .updatesGelenkstellungen und Flags.
Schreiben (Dienst)
ArmRing.write(_:_:)Schreibt der Aktor-Dienst.

SwiftCANFrameCAN- und CAN-FD-Rahmen über einen Kanal

AufrufWas er tutShape-Aufruf · Zeitbudget
Rahmen bauen
CANFrame(identifier: UInt32, fd: Bool = true)Rahmen bis 64 Datenbytes.
Beispiel
var setpoint = CANFrame(identifier: UInt32(0x100 + jointNumber))
setpoint.setInt32(grantedTarget, at: 0)
setpoint.setInt32(grantedSpeed, at: 4)
aus apps/actuators (gekürzt)
CANFrame.int32(at offset: Int) -> Int32 / .setInt32(_:at:)Werte im Rahmen (little-endian).
Senden & kodieren
CANFrame.encode(into:) -> Int / .decode(_:count:) -> CANFrame?Als Kanalnachricht.
Channel.send(_ frame: CANFrame) -> BoolRahmen über einen Kanal senden.
Beispiel
_ = bus!.send(stop)   // stop: CANFrame(identifier: 0x000)
aus apps/actuators (gekürzt)

Für Reflex-SkripteShape-Aufrufe, die Reflex-Skripte direkt beim Namen rufen

AufrufWas er tutShape-Aufruf · Zeitbudget
Bewegen
robot.moveBewegung starten (Effekt; der Aktor-Dienst führt sie aus).≤ 20 µsrobot.move0x0101_0001
robot.stateWinkel, Geschwindigkeit, Strom, Temperatur eines Gelenks.≤ 5 µsrobot.state0x0101_0002
arm.torqueDrehmoment für Echtzeitregelung (nur Echtzeit-Handler).≤ 1 µsarm.torque0x0102_0004
Beispiel: Gelenk 1 über den Aktor-Dienst bewegen, Not-Halt (apps/arm)
// manifest: capabilities = system.log, channels.ipc, ui.surface, safety.stop
guard var actuator = Channel("actuator") else { System.log("arm: no actuator channel"); return }

private func move(_ to: Int32, _ actuator: inout Channel) {
    var bytes = InlineArray<9, UInt8>(repeating: 0)
    bytes[0] = 1                                   // 1 = move
    let values: InlineArray<2, Int32> = [to, 3_000] // Ziel und Geschwindigkeit in 0,01°
    for index in 0..<2 {
        let bits = UInt32(bitPattern: values[index])
        for byte in 0..<4 { bytes[1 + 4 * index + byte] = UInt8(truncatingIfNeeded: bits >> UInt32(8 * byte)) }
    }
    _ = actuator.send(bytes.span)
    actuator.notify()
}

// Antworten: 2 = Bewegung angenommen/begrenzt/abgelehnt, 3 = Status eines Gelenks
while let count = actuator.receive(into: &message), count >= 13 { /* ... */ }

// Not-Halt-Knopf:
System.emergencyStop(reason: 1)
// Freigeben:
System.releaseEmergencyStop()
Beispiel: Arm-Zustand lesen und Kinematik (apps/server, Live.swift)
// manifest: subscribe = actuators.arm
guard let ring = Publications.subscriptionRing(0), let state = ArmRing.read(ring) else { return }
let model = ArmModel.chosen(state.id, count: state.idLength)
var q = ArmAngles()
for joint in 0..<model.count {
    q[joint] = Double(state.positions[joint]) / 100 * Double.pi / 180   // 0,01° → Radiant
}
let pose = model.forward(q)                       // pose.tip, pose.points
if let reach = model.inverse(x: 300, y: 0, z: 120, pitch: -Maths.pi / 2, near: q) { _ = reach }
Alle 97 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
ArmAngles.init()
ArmAngles.static func == (a: ArmAngles, b: ArmAngles) -> Bool
ArmAngles.subscript(_ index: Int) -> Double
ArmAngles.var values
ArmCamera.func fromWorld(_ p: ArmPoint) -> (x: Double, y: Double, depth: Double)?
ArmCamera.func toWorld(x: Double, y: Double, depth: Double?) -> ArmPoint?
ArmCamera.init(_ model: ArmModel, _ q: ArmAngles)
ArmCamera.static let focal
ArmCamera.static let width
ArmCamera.var position
ArmJoint.init(_ name: StaticString, _ low: Double, _ high: Double, fastest: Double, strongest: Double,
ArmJoint.var a
ArmJoint.var low: Double, high: Double, fastest: Double
ArmJoint.var name: StaticString
ArmJoint.var origin
ArmJoint.var rest
ArmJoint.var strongest: Double
ArmModel.func forward(_ q: ArmAngles) -> ArmPose
ArmModel.func inverse(x: Double, y: Double, z: Double, pitch: Double, near: ArmAngles) -> ArmAngles?
ArmModel.func joint(_ index: Int) -> ArmJoint
ArmModel.static func chosen<let n: Int>(_ id: InlineArray<n, UInt8>, count: Int) -> ArmModel
ArmModel.static func index<let n: Int>(of id: InlineArray<n, UInt8>, count: Int) -> Int?
ArmModel.static func model(_ index: Int) -> ArmModel
ArmModel.static let ids: InlineArray<7, StaticString>
ArmModel.static let maximumJoints
ArmModel.static let sr6
ArmModel.var base
ArmModel.var cameraBack
ArmModel.var closedForm: Bool
ArmModel.var count: Int
ArmModel.var id: StaticString
ArmModel.var index
ArmModel.var joints: InlineArray<7, ArmJoint>
ArmModel.var maker: StaticString
ArmModel.var modified: Bool
ArmModel.var name: StaticString
ArmModel.var payload
ArmModel.var reach
ArmModel.var restAngles: ArmAngles
ArmModel.var tool
ArmModel.var toolAxis
ArmModel.var toolOrigin
ArmModel.var urdf
ArmPoint.init(_ x: Double = 0, _ y: Double = 0, _ z: Double = 0)
ArmPoint.var x
ArmPose.var approach
ArmPose.var pitch
ArmPose.var pointCount
ArmPose.var points
ArmPose.var tip
ArmRing.static func read<Ring: SharedWords>(_ ring: Ring) -> ArmState?
ArmRing.static func write<Ring: SharedWords>(_ ring: Ring, _ state: ArmState)
ArmRing.static let magic: UInt32
ArmState.init()
ArmState.var chosen: Bool
ArmState.var count
ArmState.var flags: UInt32
ArmState.var id
ArmState.var idLength
ArmState.var moving: Bool
ArmState.var positions
ArmState.var stopped: Bool
ArmState.var updates: UInt32
CANFrame.func encode(into message: inout InlineArray<80, UInt8>) -> Int
CANFrame.func int32(at offset: Int) -> Int32
CANFrame.init()
CANFrame.init(identifier: UInt32, fd: Bool = true)
CANFrame.mutating func setInt32(_ value: Int32, at offset: Int)
CANFrame.static func decode(_ message: InlineArray<256, UInt8>, count: Int) -> CANFrame?
CANFrame.var data
CANFrame.var extended
CANFrame.var fd
CANFrame.var identifier: UInt32
CANFrame.var length
Channel.func send(_ frame: CANFrame) -> Bool
SimulatedMotors.init(_ model: ArmModel = .sr6)
SimulatedMotors.mutating func emergencyStop(_ on: Bool)
SimulatedMotors.mutating func set(joint: Int, target value: Int32, speed limit: Int32)
SimulatedMotors.mutating func step(milliseconds: Int)
SimulatedMotors.var count: Int
SimulatedMotors.var model: ArmModel
SimulatedMotors.var moving: Bool
SimulatedMotors.var position
SimulatedMotors.var speed
SimulatedMotors.var stopped
SimulatedMotors.var target
SimulatedMotors.var velocity
enum ArmRing
struct ArmAngles: Equatable, Sendable
struct ArmCamera
struct ArmJoint: Sendable
struct ArmModel: Sendable
struct ArmPoint: Sendable
struct ArmPose: Sendable
struct ArmState
struct CANFrame
struct SimulatedMotors

safety · Der Not-Halt

Den Not-Halt hält der Kern selbst. Jedes Programm darf ihn lesen (safety.state, ohne Recht); auslösen und lösen dürfen nur Programme mit safety.stop, und nur der Aktor-Dienst hält safety.actuator. Programme sehen eine Generation, die sich mit jedem Halt und jeder Freigabe ändert (ungerade = gehalten).

Teile nur für Systemprogramme: System-API › safety.

Rechte

Kein Recht nötig, um den Not-Halt zu lesen.

SystemaufrufesafetyModul 0x0100 · Der Not-Halt (lesen frei, stop/release mit safety.stop).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
safety.stateSafetyQuery → SafetyStatekeins≤ 2 µs0x0100_0001

SwiftSystemNot-Halt lesen

AufrufWas er tutShape-Aufruf · Zeitbudget
Zustand lesen
System.emergencyStopped: BoolGilt der Not-Halt gerade?≤ 2 µssafety.state0x0100_0001
Beispiel
let stopped = System.emergencyStopped
aus apps/arm (gekürzt)
System.safetyGeneration: UInt64Ändert sich mit jedem Halt und jeder Freigabe; ungerade = gehalten.≤ 2 µssafety.state0x0100_0001
Beispiel
let now = System.safetyGeneration
if now != safety { safety = now; motors.emergencyStop(now & 1 == 1) }
aus apps/actuators (gekürzt)
System.safetyState: SafetyStategeneration, stopped, sinceStop.≤ 2 µssafety.state0x0100_0001
System.microsecondsSinceStop: UInt64µs seit dem letzten Halt.≤ 2 µssafety.state0x0100_0001

Für Reflex-SkripteShape-Aufrufe, die Reflex-Skripte direkt beim Namen rufen

AufrufWas er tutShape-Aufruf · Zeitbudget
Not-Halt
safety.state / stop / releaseNot-Halt lesen, auslösen, lösen.≤ 20 µssafety.stop0x0100_0002
Alle 4 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
System.static var emergencyStopped: Bool
System.static var microsecondsSinceStop: UInt64
System.static var safetyGeneration: UInt64
System.static var safetyState: SafetyState

channels · Kanäle zwischen Programmen, Veröffentlichungen

Mit channels.ipc: Zwei Programme, die denselben Namen öffnen, teilen eine Seite mit einem Nachrichtenring in jede Richtung (Nachrichten bis 256 Bytes). Wecken und Warten sind primitive Systemaufrufe (channelNotify, channelWait). Läuft die Gegenseite auf einer anderen CPU, fragt receiveWaiting den Ring erst kurz ab – meist antwortet sie binnen Mikrosekunden. So reden auch Roboterprogramme mit dem Aktor-Dienst (actuator) und Treiber untereinander (CAN-Rahmen).

Veröffentlichungen: ein Programm mit publish = … schreibt einen Ring, den Programme mit subscribe = … ohne Systemaufruf lesen (die Erkennungen von Video, der Arm-Zustand des Aktor-Dienstes).

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
channels.ipcKanäle zwischen Programmen öffnen.≤ 1 mschannels.open0x000A_0001

SystemaufrufechannelsModul 0x000A · Nachrichtenkanäle zwischen Programmen (channels.ipc).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
channels.openChannelName → ChannelOpenedchannels.ipc≤ 1 ms0x000A_0001

SystemaufrufepeersModul 0x0110 · Roboter in der Nähe (für später reserviert).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
peers.listPeersRequest → PeerListkeins · vom Kern noch nicht bedientohne Budget0x0110_0001
peers.sendEnvelope → Deliveredkeins · vom Kern noch nicht bedientohne Budget0x0110_0002
peers.received eventEnvelopeReflex-EreignisEreignis0x0110_0003

SwiftChannelEin Kanal

AufrufWas er tutShape-Aufruf · Zeitbudget
Öffnen
Channel.init?(_ name: StaticString)Kanal öffnen oder beitreten; nil ohne channels.ipc.≤ 1 mschannels.open0x000A_0001
Beispiel
guard var channel = Channel("bench") else { System.log("ipcping: channel refused"); return }
aus apps/ipcping (gekürzt)
Channel.handle: UInt64Nummer des Kanals.
Senden
Channel.send(_ message: Span<UInt8>) -> BoolNachricht einreihen (höchstens 256 Bytes); false bei vollem Ring.
Beispiel
while !channel.send(message.span) { System.yield() }
aus apps/ipcping (gekürzt)
Channel.send(_ frame: CANFrame) -> BoolEinen CAN-Rahmen senden.
Channel.notify()Die Gegenseite wecken.channelNotify (Systemaufruf 8)
Beispiel
_ = actuator.send(bytes.span)
actuator.notify()
aus apps/arm (gekürzt)
Empfangen
Channel.receive(into out: inout InlineArray<256, UInt8>) -> Int?Älteste eingegangene Nachricht oder nil (wartet nicht).
Beispiel
while let count = actuator.receive(into: &message), count >= 13 { /* Antwort auswerten */ }
aus apps/arm (gekürzt)
Channel.receiveWaiting(into out: inout InlineArray<256, UInt8>) -> IntBlockiert, bis eine Nachricht kommt (verlorene Weckrufe abgefangen).channelWait (Systemaufruf 9)
Beispiel
let count = channel.receiveWaiting(into: &reply)
aus apps/ipcping (gekürzt)
Channel.receivePolling(into out: inout InlineArray<256, UInt8>, microseconds: UInt64 = 30) -> Int?Nächste Nachricht, wenn sie binnen µs kommt (nur bei Gegenseite auf anderer CPU).
Beispiel
if open.receivePolling(into: &answer) != nil { return true }
aus apps/benchmark (gekürzt)
Channel.peerOnSameCPU: BoolOb die Gegenseite beim letzten notify() auf der CPU dieses Programms lief; dann verzögert Abfragen (Polling) ihre Antwort nur, und ein Hin und Zurück dauert 6-8 µs statt 1,2-1,7 µs (F184).
Channel.wait(timeout: UInt64)Schläft bis zum Weckruf oder Ablauf; kann früher zurückkehren.channelWait (Systemaufruf 9)
Beispiel
channel!.wait(timeout: 50_000_000)
aus apps/develop (gekürzt)

SwiftPublicationsVeröffentlichen und abonnieren (publish =, subscribe =)

AufrufWas er tutShape-Aufruf · Zeitbudget
Veröffentlichen
Publications.detections() -> DetectionWriter<SharedRing>?staticDer eigene Erkennungsring zum Schreiben; nil ohne publish =.
Beispiel
nonisolated(unsafe) var publisher = Publications.detections()
aus apps/video (gekürzt)
Abonnieren
Publications.subscription(_ index: Int = 0) -> DetectionReader<SharedRing>?staticDas index-te Abo (0 oder 1, Reihenfolge im Manifest).
Beispiel
guard let ring = Publications.subscription(0) else { System.log("rtvision: no subscription (subscribe line missing)"); return }
aus apps/rtvision (gekürzt)
Rohe Ringe
Publications.ownRing() -> SharedRing? / Publications.subscriptionRing(_ index: Int) -> SharedRing?staticDieselben Ringe als rohe Wörter (für andere Formate, z. B. den Arm-Ring).

SwiftSharedPage · SharedRingRohe geteilte Wörter

AufrufWas er tutShape-Aufruf · Zeitbudget
Rohe geteilte Wörter
SharedPage.load / .store / .loadAcquire / .storeReleaseDie Kanalseite Wort für Wort (geordnete Zugriffe).
SharedRing.load32 / .store32 / .loadAcquire32 / .storeRelease32 / .barrierEine Veröffentlichung Wort für Wort.
Beispiel: Hin und zurück über den Kanal "bench" (apps/ipcping)
// manifest: capabilities = system.log, channels.ipc
guard var channel = Channel("bench") else {
    System.log("ipcping: channel refused")
    return
}
var reply = InlineArray<256, UInt8>(repeating: 0)
var message = InlineArray<64, UInt8>(repeating: 0x42)
for round in 0..<2_000 {
    message[0] = UInt8(truncatingIfNeeded: round)
    while !channel.send(message.span) { System.yield() }
    channel.notify()
    let count = channel.receiveWaiting(into: &reply)
    guard count == 64, reply[0] == message[0] else { System.log("ipcping: wrong reply"); return }
}
Alle 27 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
Channel.func receive(into out: inout InlineArray<256, UInt8>) -> Int?
Channel.func receivePolling(into out: inout InlineArray<256, UInt8>, microseconds: UInt64 = 30) -> Int?
Channel.func receiveWaiting(into out: inout InlineArray<256, UInt8>) -> Int
Channel.func send(_ message: Span<UInt8>) -> Bool
Channel.func wait(timeout: UInt64)
Channel.init?(_ name: StaticString)
Channel.let handle: UInt64
Channel.mutating func notify()
Channel.private(set) var peerOnSameCPU
Publications.static func detections() -> DetectionWriter<SharedRing>?
Publications.static func ownRing() -> SharedRing?
Publications.static func subscription(_ index: Int = 0) -> DetectionReader<SharedRing>?
Publications.static func subscriptionRing(_ index: Int) -> SharedRing?
SharedPage.func load(_ offset: Int) -> UInt32
SharedPage.func loadAcquire(_ offset: Int) -> UInt32
SharedPage.func store(_ offset: Int, _ value: UInt32)
SharedPage.func storeRelease(_ offset: Int, _ value: UInt32)
SharedPage.let base: UInt64
SharedRing.func barrier()
SharedRing.func load32(_ offset: Int) -> UInt32
SharedRing.func loadAcquire32(_ offset: Int) -> UInt32
SharedRing.func store32(_ offset: Int, _ value: UInt32)
SharedRing.func storeRelease32(_ offset: Int, _ value: UInt32)
enum Publications
struct Channel
struct SharedPage: RingMemory
struct SharedRing: SharedWords

clipboard · Kopieren und Einsetzen

Text bis 64 KiB, eine für das ganze System. Jedes Programm mit Fenster darf kopieren; lesen darf es nur direkt nachdem der Besitzer in diesem Programm „Einsetzen“ gewählt hat (der Display-Dienst gibt einen Lesezugriff innerhalb von zwei Sekunden frei). Kein Programm kann die Zwischenablage beobachten. Das Standard-Bearbeiten-Menü (addEditMenu) und InputField erledigen das von selbst.

Teile nur für Systemprogramme: System-API › clipboard.

Rechte

Kein eigenes Recht: Kopieren braucht ein Fenster (ui.surface); Einsetzen geht nur direkt nach der Wahl des Besitzers.

SystemaufrufeclipboardModul 0x0012 · Kopieren und Einsetzen.

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
clipboard.copyClipText → Doneui.surface≤ 50 µs0x0012_0001
clipboard.pastePasteRequest → ClipTextkeins≤ 50 µs0x0012_0002
clipboard.generationPasteRequest → ClipGenerationkeins≤ 2 µs0x0012_0004

SwiftClipboardKopieren, Einsetzen

AufrufWas er tutShape-Aufruf · Zeitbudget
Kopieren
Clipboard.copy(_ text: Span<UInt8>) -> BoolstaticText (UTF-8, höchstens 64 KiB) in die Zwischenablage.≤ 50 µsclipboard.copy0x0012_0001
Beispiel
_ = Clipboard.copy(text.span.extracting(0..<length))
aus apps/console (gekürzt)
Clipboard.generation: UInt64staticZähler, der mit jedem Kopieren wächst (die Mac-Brücke).≤ 2 µsclipboard.generation0x0012_0004
Einsetzen
Clipboard.paste(into buffer: inout MutableSpan<UInt8>) -> IntstaticLiest in buffer; 0 wenn leer oder gerade nicht freigegeben.≤ 50 µsclipboard.paste0x0012_0002
Beispiel
var buffer = [UInt8](repeating: 0, count: 64 * 1024)
var span = buffer.mutableSpan
let length = Clipboard.paste(into: &span)
aus apps/develop (gekürzt)
Beispiel: Kopieren und Einsetzen im Editor (apps/develop)
switch id {
case EditMenu.copy, EditMenu.cut:
    guard Editor.hasSelection else { return }
    let bytes = Editor.selectedBytes
    _ = bytes.withUnsafeBufferPointer { Clipboard.copy(Span(_unsafeElements: $0)) }
    if id == EditMenu.cut { Editor.insert([]) }
case EditMenu.paste:
    var buffer = [UInt8](repeating: 0, count: 64 * 1024)
    var span = buffer.mutableSpan
    let length = Clipboard.paste(into: &span)
    _ = span
    guard length > 0 else { return }
    Editor.insert(Array(buffer[0..<length]))
default: break
}
Alle 4 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
Clipboard.static func copy(_ text: Span<UInt8>) -> Bool
Clipboard.static func paste(into buffer: inout MutableSpan<UInt8>) -> Int
Clipboard.static var generation: UInt64
enum Clipboard

dialog · Öffnen und Sichern über das System

Datei-Dialog (neu, 10.11.): „Wählen ist Erlauben“. Das Programm fragt mit Dialog.open oder Dialog.save; das Systemprogramm chooser zeigt den Dialog; was die Person wählt, wird eine Freigabe (FileGrant) für genau diese Datei – geöffnet mit Files.Handle.open(grant, mode:), ganz ohne Datei-Recht im Manifest. Der Dialog zeigt den eigenen Ordner, die gemeinsamen Dokumente und in der VM den Mac-Ordner, nie Ordner anderer Programme. Eine Frage pro Programm zur Zeit; bis 16 Freigaben, solange das Programm läuft. Nicht für Echtzeit-Programme.

Teile nur für Systemprogramme: System-API › dialog.

Rechte

Kein eigenes Recht: Fragen braucht ein Fenster (ui.surface); die gewählte Datei öffnet ohne Datei-Recht.

SystemaufrufedialogModul 0x0013 · Öffnen- und Sichern-Dialog des Systems (neu, 10.11.).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
dialog.ask neuDialogAsk → DialogTicketui.surface≤ 1 ms0x0013_0001
dialog.result neuDialogTicket → DialogResultkeins≤ 20 µs0x0013_0002

SwiftDialogFragen und Antwort abholen

AufrufWas er tutShape-Aufruf · Zeitbudget
Öffnen
Dialog.open(types: StaticString = "", action: StaticString = "") -> Boolstatic neuFragt nach einer Datei zum Öffnen; types = Endungen mit Leerzeichen ("wav flac"; leer: alles aus opens). Kehrt sofort zurück; false wenn schon ein Dialog offen ist.≤ 1 msdialog.ask0x0013_0001
Beispiel
_ = Dialog.open(types: "reflex srshare", action: "Import")
aus apps/develop (gekürzt)
Sichern
Dialog.save(name: TextLine, formats: StaticString, action: StaticString = "") -> Boolstatic neuFragt, wohin gesichert wird; formats eine Zeile je Format "Label=endung"; action = Wort auf dem Knopf ("Export").≤ 1 msdialog.ask0x0013_0001
Beispiel
if !Dialog.save(name: suggested, formats: "Script package=srshare", action: "Share") { Runner.note("A file dialog is open already.", .warning) }
aus apps/develop (gekürzt)
Antwort abholen
Dialog.answer() -> Answer?static neuDie Antwort, sobald es eine gibt (billig, in jeder Schleifenrunde fragen): .chosen(FileGrant) oder .cancelled; nil solange offen.≤ 20 µsdialog.result0x0013_0002
Beispiel
if let answer = Dialog.answer() { Share.answered(answer); dirty = true }
aus apps/develop (gekürzt)
enum Dialog.Answer { case chosen(FileGrant), cancelled } neuErgebnis der Frage.
Zustand
Dialog.isOpen: Boolstatic neuIst ein Dialog dieses Programms gerade auf dem Bildschirm?
Beispiel
if Dialog.isOpen { return }   // nicht ein zweites Mal fragen
Muster (kurz, nicht aus einem Programm kopiert)
Dialog.lastWasSavestatic neuWar die letzte Frage ein Sichern (um Antworten zu unterscheiden)?
Beispiel
if case .chosen(let grant)? = Dialog.answer() {
    if Dialog.lastWasSave { save(to: grant) } else { load(grant) }
}
Muster (kurz, nicht aus einem Programm kopiert)

SwiftFileGrantEine Freigabe für genau eine Datei

AufrufWas er tutShape-Aufruf · Zeitbudget
Freigabe
FileGrant.number: Int neuNummer der Freigabe (1 … 16).
FileGrant.name: TextLine neuGewählter Dateiname.
FileGrant.place: DialogPlace neuWo sie liegt: eigener Ordner, Dokumente oder Mac-Ordner.
FileGrant.format neuBeim Sichern: Index des gewählten Formats.
Datei öffnen
Files.Handle.open(_ grant: FileGrant, mode: Mode) -> Result<Files.Handle, FileError> neuÖffnet die freigegebene Datei (lesen oder schreiben) – ohne Datei-Recht.≤ 2 msfiles.open0x0003_0001
Beispiel
guard case .success(let file) = Files.Handle.open(grant, mode: .replace) else { return false }
aus apps/develop (gekürzt)
Beispiel: Dateimenü mit „Öffnen…“ und die Antwort in der Schleife (apps/reader)
surface.addFileMenu(open: true)
surface.addEditMenu(1)
surface.addMenu(2, "View")
surface.addItem(2, "Zoom In", id: Item.zoomIn, key: 0x2B, icon: .zoomIn)   // +
surface.addItem(2, "Zoom Out", id: Item.zoomOut, key: 0x2D, icon: .zoomOut) // -
surface.publishMenus()

while true {
    while let event = surface.nextEvent() {
        switch event {
        case .menu(let id):
            if id == FileMenu.open { _ = Dialog.open(types: "pdf") }
            else if menu(id, surface.canvas) { dirty = true }
        default: break
        }
    }
    if case .chosen(let grant)? = Dialog.answer() {
        load(grant.name, grant: grant)          // Files.Handle.open(grant, mode: .read)
        dirty = true
    }
    // ... zeichnen, wait
}
Beispiel: Exportieren als CSV oder JSON (apps/database)
surface.addFileMenu(export: true)

// Menüpunkt Export…:
if !Dialog.save(name: suggested, formats: "CSV=csv\nJSON=json", action: "Export") {
    status = TextLine("A file dialog is open already")
}

// in der Schleife:
if case .chosen(let grant)? = Dialog.answer() {
    exportRows(json: grant.format == 1, to: grant)
}

func exportRows(json: Bool, to grant: FileGrant) {
    guard case .success(let file) = Files.Handle.open(grant, mode: .replace) else {
        status = TextLine("The export file cannot be written")
        return
    }
    // ... file.write(...), file.close()
}
Alle 12 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
Dialog.enum Answer
Dialog.nonisolated(unsafe) private(set) static var lastWasSave
Dialog.static func answer() -> Answer?
Dialog.static func open(types: StaticString = "", action: StaticString = "") -> Bool
Dialog.static func save(name: TextLine, formats: StaticString, action: StaticString = "") -> Bool
Dialog.static var isOpen: Bool
FileGrant.let number: Int
FileGrant.var format
FileGrant.var name
FileGrant.var place
enum Dialog
struct FileGrant

update · Systemupdates

Kein Teil der App-API: jeder Aufruf dieses Moduls braucht ein Recht, das nur Systemprogramme bekommen. Siehe System-API › update.

protection · Geräteschutz

Kein Teil der App-API: jeder Aufruf dieses Moduls braucht ein Recht, das nur Systemprogramme bekommen. Siehe System-API › protection.

Reflex-Skripte (Develop)

Reflex ist die Sprache von Develop: Ein Ereignis rein, eine Reaktion raus. Ein Reflex-Programm ruft die Shape-Module direkt beim Namen (robot.move, vision.detections) – ohne Swift. Jede Zeile nennt ihr Modul; der Compiler sammelt daraus die Module und damit die Rechte, die beim Sichern als Programm in das signierte Manifest kommen. Von Develop gebaute Programme bekommen höchstens: Protokoll, Fenster, Ton, Kamera und Erkennungen, Mikrofon, den eigenen Ordner, Netz nur wenn erlaubt, den Roboter innerhalb seiner Grenzen über den Aktor-Dienst – nie Systemrechte.

Bausteine: state, on modul.ereignis(…) -> State, every 200 ms, realtime every 1 ms (Develop beweist die Worst-Case-Zeit, höchstens 80 % der Periode), emit modul.aufruf(…) für Effekte, func, screen { … }, test. Einheiten sind Teil der Typen (40°, 0.4 s, 880 Hz).

Die Systemaufrufe, die Reflex beim Namen ruft, stehen mit ihrem Recht bei den Modulen oben (robot, arm, vision, camera, sound, microphone, signal, screen, ask).

Reflexon …Ereignisse

AufrufWas er tutShape-Aufruf · Zeitbudget
Programm
on start / on stopProgramm startet / soll anhalten (letzte Gelegenheit zum Sichern).Ereignissystem.start0x0002_0007
every 200 msZeitgeber.
Sehen & Hören
on vision.detections(seen: Detections)Neue Erkennungen von Video.≤ 10 µsvision.detections0x0021_0001
on microphone.loud(heard: Loudness)Lauter als ein Pegel (Knall, blockierender Motor).Ereignismicrophone.loud0x0031_0008
on microphone.voice(change: VoiceChange)Sprechen begann oder endete.Ereignismicrophone.voice0x0031_0009
on camera.frame(…)Ein neues Kamerabild.≤ 10 µscamera.frame0x0020_0002
Roboter
on robot.moved(m: Motion)Eine Bewegung endete (erreicht, begrenzt oder gestoppt).Ereignisrobot.moved0x0101_0004
Fenster
on Name() (Knopf im screen)Ein Knopf des Fensters wurde gedrückt.Ereignisscreen.pressed0x0010_0003

Reflexemit …Aufrufe & Effekte

AufrufWas er tutShape-Aufruf · Zeitbudget
Roboter
emit robot.move(joint:, to:, in:)Gelenk bewegen (über die Grenzen des Aktor-Dienstes).≤ 20 µsrobot.move0x0101_0001
robot.state(joint:)Zustand eines Gelenks (auch im Echtzeit-Handler, aus dem Ring).≤ 5 µsrobot.state0x0101_0002
arm.forward / arm.inverse / arm.jointsKinematik des Arms.≤ 20 µsarm.inverse0x0102_0002
Ton & Bild
emit sound.tone(pitch:, length:)Ein Ton.≤ 20 µssound.tone0x0030_0001
camera.toWorld(p)Bildpunkt → Weltpunkt.≤ 2 µscamera.toWorld0x0020_0003
Rechnen & Fragen
signal.spectrum / filter / stats / sineSpektren und Filter über Messreihen.≤ 500 µssignal.spectrum0x0040_0001
ask.claude(…)Eine Cloud-KI fragen (über deren API, mit dem Schlüssel des Besitzers aus Settings › Privatsphäre).ohne Budgetask.claude0x0050_0001
Fenster
screen { Title Text Big Button Slider Chart Picture Row Column }Fenster als Beschreibung; Aussehen kommt vom System.≤ 200 µsscreen.show0x0010_0001
Beispiel: Klatschen hält den Arm an (apps/develop/examples/clap-stop.reflex)
state Listener {
    bangs: Int32 = 0
    lastBang: Time = 0
    talking: Bool = false
}

/// A bang: hold the arm (every joint stays where it is) and beep.
on microphone.loud(heard: Loudness) -> Listener {
    if isBang(level: heard.peak) and heard.taken - lastBang > 1 s {
        emit robot.move(joint: 1, to: 0°, in: 2 s)
        emit sound.tone(pitch: 660 Hz, length: 150 ms)
        return self with { bangs: bangs + 1, lastBang: heard.taken }
    }
    return self
}

on microphone.voice(change: VoiceChange) -> Listener {
    if change.speaking and not talking {
        emit robot.move(joint: 5, to: 20°, in: 0.3 s)
    }
    return self with { talking: change.speaking }
}

func isBang(BangLevel { level: Float32 }) -> Bool { return level > -6 }

test "a clap is a bang" { expect isBang(level: -3) }
Beispiel: Echtzeit-Handler, von Develop bewiesen (apps/develop/guide/6-realtime.reflex)
state Hold {
    target: Angle = 30°
    periods: Int32 = 0
}

realtime every 1 ms -> Hold {
    let joint = robot.state(joint: 1)
    if periods % 20 == 0 {
        emit robot.move(joint: 1, to: joint.angle + step(gap: target - joint.angle).value, in: 20 ms)
    }
    return self with { periods: periods + 1 }
}

func step(Gap { gap: Angle }) -> Turn {
    if gap > 1° { return Turn(value: 1°) }
    if gap < -1° { return Turn(value: -1°) }
    return Turn(value: gap)
}

shape Turn { value: Angle }

System-API

Nur für Systemprogramme – nicht Teil der App-API, kann sich ändern

Hier steht, was Systemprogramme brauchen: alles, wofür ein Recht außerhalb der 9 Rechte nötig ist, die ein normales, nicht vom System signiertes Programm haben kann (Capability.fromDevelop in kernel/lib/AppManifest.swift: camera.use, channels.ipc, files.own, network.outgoing, sound.microphone, sound.play, system.log, system.status, ui.surface). Solche Rechte bekommt nur ein Programm mit dem Schlüssel des Systems; ein Manifest, das sie für ein Programm in /apps verlangt, wird abgelehnt.

Diese Aufrufe sind nicht Teil der App-API: sie werden zu 1.0 nicht eingefroren und können sich ändern. Gegliedert ist dieser Teil nach denselben Modulen wie die App-API.

Rechte23 Rechte nur für Systemprogramme

RechtModul
system.log.readsystem
system.powersystem
system.privacysystem
system.timesystem
programs.buildprograms
programs.launchprograms
files.macfiles
files.systemfiles
database.editdatabase
network.incomingnetwork
ui.displayui
ui.inputui
ui.input.provideui
sound.microphone.providesound
sound.volumesound
camera.providecamera
device.canrobot
device.usbrobot
safety.actuatorsafety
safety.stopsafety
files.dialogdialog
system.updateupdate
system.protectionprotection

system · Information, Zeit, Protokoll, Echtzeit, Text

Nur für Systemprogramme – nicht Teil der App-API, kann sich ändern

Uhr stellen (der Zeitdienst, system.time), Ausschalten und Neustarten (system.power), das Systemprotokoll lesen (Konsole, Activity: system.log.read) und Geheimnisse wie API-Schlüssel setzen (Settings: system.privacy).

Was jedes Programm davon nutzen darf: App-API › system.

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
system.log.readDas Systemprotokoll lesen (Konsole, Activity).≤ 20 µssystem.readLog0x0002_0005
system.timeDie Systemuhr stellen (Zeitdienst nach NTS).≤ 5 µssystem.adjustClock0x0002_000A
system.powerAusschalten und Neustarten.ohne Budgetsystem.power0x0002_0004
system.privacyGeheimnisse wie API-Schlüssel für Programme setzen (Settings).≤ 5 msprograms.setSecret0x0006_0004

SystemaufrufesystemModul 0x0002 · Der Roboter selbst: Info, Zeit, Protokoll, Strom, Zufall, Prozessoren, Worker-Threads; Ereignisse start/stop.

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
system.powerPowerRequest → Donesystem.powerohne Budget0x0002_0004
system.readLogLogRead → LogTextsystem.log.read≤ 20 µs0x0002_0005
system.adjustClockClockAdjust → Nowsystem.time≤ 5 µs0x0002_000A

SystemaufrufeSystemCallprimitive Systemaufrufe (enum SystemCall)

NameWas er tutRechtNummer
deviceWaitTreiber: auf Interrupt wartendevice.usb10
inputReceiveDisplay-Dienst: Eingaben abholenui.input12

SwiftSystemUhr stellen, Strom

AufrufWas er tutShape-Aufruf · Zeitbudget
Zeit
System.adjustClock(byMilliseconds offset: Int64) -> UInt64?Uhr verstellen (system.time).≤ 5 µssystem.adjustClock0x0002_000A
Strom
System.power(restart: Bool)Aus oder Neustart (system.power); kehrt nur bei Ablehnung zurück.ohne Budgetsystem.power0x0002_0004

SwiftProgramsDas Systemprotokoll lesen (system.log.read)

AufrufWas er tutShape-Aufruf · Zeitbudget
Protokoll lesen
Programs.logEnd / Programs.logLine(from:into:)Das Systemprotokoll mitlesen (system.log.read).≤ 20 µssystem.readLog0x0002_0005
Beispiel
var position = Programs.logEnd
var line = InlineArray<160, UInt8>(repeating: 0)
while let length = Programs.logLine(from: &position, into: &line) { /* line[0..<length] */ }
Muster (kurz, nicht aus einem Programm kopiert)
Alle 4 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
Programs.static func logLine(from position: inout UInt64, into line: inout InlineArray<160, UInt8>) -> Int?
Programs.static var logEnd: UInt64
System.static func adjustClock(byMilliseconds offset: Int64) -> UInt64?
System.static func power(restart: Bool)

programs · Das eigene Programm, Einstellungen, andere Programme

Nur für Systemprogramme – nicht Teil der App-API, kann sich ändern

Andere Programme starten, stoppen, auflisten, ihre Signatur und Abstürze lesen, löschen (Desktop, Konsole, Files, Activity: programs.launch) und Programme aus Skripten bauen (Develop: programs.build).

Was jedes Programm davon nutzen darf: App-API › programs.

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
programs.launchProgramme starten, stoppen, auflisten, Dokumente übergeben, Abstürze lesen.≤ 50 msprograms.launch0x0006_0007
programs.buildProgramme aus Skripten mit dem Schlüssel dieses Roboters bauen (Develop).≤ 3 sprograms.build0x0006_0010

SystemaufrufeprogramsModul 0x0006 · Das Programm selbst und die anderen: Dokument, Settings, Geheimnis, Start/Stopp, Listen, Abstürze, Bauen.

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
programs.setSecretSecretWrite → Donesystem.privacy≤ 5 ms0x0006_0004
programs.hasSecretSecretQuery → SecretPresencesystem.privacy≤ 2 ms0x0006_0005
programs.launchProgramName → Doneprograms.launch≤ 50 ms0x0006_0007
programs.stopProgramName → Doneprograms.launch≤ 50 µs0x0006_0008
programs.openOpenDocument → Doneprograms.launch (+ files.system für fremde Dateien)≤ 50 ms0x0006_0009
programs.runningProgramListQuery → RunningProgramsprograms.launch≤ 50 µs0x0006_000A
programs.installedProgramListQuery → InstalledProgramsprograms.launch≤ 20 ms0x0006_000B
programs.presentationProgramName → ProgramLookprograms.launch≤ 5 ms0x0006_000C
programs.crashesProgramListQuery → CrashListprograms.launch≤ 20 µs0x0006_000D
programs.signatureProgramName → SignatureCheckprograms.launch≤ 50 ms0x0006_000F
programs.buildBuildProgram → BuiltProgramprograms.build≤ 3 s0x0006_0010
programs.signShareSharePackage → ShareSignatureprograms.build≤ 20 ms0x0006_0011
programs.checkShareSharePackage → ShareCheckprograms.build≤ 20 ms0x0006_0012
programs.uninstallUninstall → Donefiles.system + programs.launch≤ 3 s0x0006_0013
programs.leftoversProgramListQuery → Leftoversfiles.system≤ 50 ms0x0006_0014
programs.deleteLeftoverLeftoverDelete → Donefiles.system + programs.launch≤ 3 s0x0006_0015

SwiftProgramsStarten, stoppen, Listen, Abstürze, Signatur, Löschen

AufrufWas er tutShape-Aufruf · Zeitbudget
Starten & stoppen
Programs.launch(_ name: Span<UInt8>) -> FileError?Systemprogramm oder App starten (programs.launch).≤ 50 msprograms.launch0x0006_0007
Beispiel
_ = callcost.withUTF8Buffer { Programs.launch(Span(_unsafeElements: $0)) }
aus apps/apicheck (gekürzt)
Programs.stop(_ name: Span<UInt8>) -> FileError?Laufendes Programm stoppen (Dienste nicht).≤ 50 µsprograms.stop0x0006_0008
Beispiel
return Programs.stop(name.span.extracting(0..<count)) == nil
aus apps/activity (gekürzt)
Programs.open(_ program: Span<UInt8>, document path: Span<UInt8>) -> FileError?Programm mit einem Dokument starten oder es ihm übergeben.≤ 50 msprograms.open0x0006_0009
Beispiel
return Programs.open(program.span, document: path.span) == nil
aus apps/files (gekürzt)
Listen
Programs.running(at index: Int) -> Running?Das index-te laufende Programm (Index 0 fragt neu).≤ 50 µsprograms.running0x0006_000A
Beispiel
while let program = Programs.running(at: index) { index += 1 }
aus apps/console (gekürzt)
Programs.installed(at index: Int) -> Running?Das index-te installierte Programm.≤ 20 msprograms.installed0x0006_000B
Beispiel
while let entry = Programs.installed(at: index) { index += 1 }
aus apps/display (gekürzt)
Programs.Running: name, id, version, kind, realtime, period, missed, worstLatency, onDemand, helper, seesCamera, hearsMicrophone …Was ein Eintrag zeigt.
Programs.Running.hiddenFromDock neuInstalliert mit dock = no.
Abstürze & Signatur
Programs.crash(at index: Int) -> Crash?Die letzten 8 Abstürze, neueste zuerst: name, reason, sequence, wallClock, pc, memoryLimit, reportPath.≤ 20 µsprograms.crashes0x0006_000D
Beispiel
while let crash = Programs.crash(at: index) { System.log(crash.reportPath); index += 1 }
Muster (kurz, nicht aus einem Programm kopiert)
Programs.signature(of name: Span<UInt8>) -> SignatureState?Signatur prüfen wie beim Start.≤ 50 msprograms.signature0x0006_000F
Programs.presentation(of name: Span<UInt8>, into buffer: UnsafeMutableRawPointer) -> Presentation?Titel, Gruppe und Symbol eines Programms (Dock).≤ 5 msprograms.presentation0x0006_000C
Löschen
Programs.uninstall(_ name: Span<UInt8>, deleteData: Bool, password: Span<UInt8>) -> TextLine?Programm aus /apps löschen (Passwort des Besitzers; files.system + programs.launch).≤ 3 sprograms.uninstall0x0006_0013
Programs.leftover(at:) / Programs.deleteLeftover(_:password:)Datenordner gelöschter Programme.≤ 50 msprograms.leftovers0x0006_0014
Beispiel: Die letzten Abstürze auflisten (programs.launch)
var index = 0
while let crash = Programs.crash(at: index) {
    var line = TextLine()
    for i in 0..<crash.nameLength { line.append(byte: crash.name[i]) }
    line.append(": ")
    line.append(crash.reportPath)
    System.log(line)
    index += 1
}
Alle 53 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
Programs.Crash.init()
Programs.Crash.var memoryLimit: UInt64
Programs.Crash.var name
Programs.Crash.var nameLength
Programs.Crash.var pc: UInt64
Programs.Crash.var reason
Programs.Crash.var reportPath: TextLine
Programs.Crash.var sequence: UInt64
Programs.Crash.var wallClock: Int64
Programs.Leftover.var deleted: Int64
Programs.Leftover.var id
Programs.Leftover.var idLength
Programs.Leftover.var size: UInt64
Programs.Leftover.var version: UInt64
Programs.Presentation.var category
Programs.Presentation.var iconLength
Programs.Presentation.var title
Programs.Presentation.var titleRefused
Programs.Running.var hearsMicrophone
Programs.Running.var helper
Programs.Running.var hiddenFromDock
Programs.Running.var id
Programs.Running.var idLength
Programs.Running.var kind
Programs.Running.var missed: UInt64
Programs.Running.var name
Programs.Running.var nameLength
Programs.Running.var onDemand
Programs.Running.var period: UInt64
Programs.Running.var periods: UInt64
Programs.Running.var realtime
Programs.Running.var seesCamera
Programs.Running.var sends
Programs.Running.var slot
Programs.Running.var version: UInt64
Programs.Running.var worstLatency: UInt64
Programs.static func crash(at index: Int) -> Crash?
Programs.static func deleteLeftover(_ id: Span<UInt8>, password: Span<UInt8>) -> TextLine?
Programs.static func installed(at index: Int) -> Running?
Programs.static func launch(_ name: Span<UInt8>) -> FileError?
Programs.static func leftover(at index: Int) -> Leftover?
Programs.static func open(_ program: Span<UInt8>, document path: Span<UInt8>) -> FileError?
Programs.static func presentation(of name: Span<UInt8>, into buffer: UnsafeMutableRawPointer) -> Presentation?
Programs.static func running(at index: Int) -> Running?
Programs.static func signature(of name: Span<UInt8>) -> SignatureState?
Programs.static func stop(_ name: Span<UInt8>) -> FileError?
Programs.static func uninstall(_ name: Span<UInt8>, deleteData: Bool, password: Span<UInt8>) -> TextLine?
Programs.static let presentationBytes
Programs.static let presentationIcon
Programs.struct Crash
Programs.struct Leftover
Programs.struct Presentation
Programs.struct Running

files · Dateien und Ordner

Nur für Systemprogramme – nicht Teil der App-API, kann sich ändern

Das ganze DATA-Volume (files.system: Konsole, Files), der Mac-Ordner in der VM (files.mac), Schnappschüsse für den Zeitschieber und „In Files zeigen“.

Was jedes Programm davon nutzen darf: App-API › files.

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
files.systemDas ganze DATA-Volume (/apps nur lesend), Snapshots.≤ 50 µsfiles.snapshot0x0003_000C
files.macZusätzlich den Mac-Ordner mac/… (nur SOFTrobotsVM).

SystemaufrufefilesModul 0x0003 · Dateien des Programms, Ordner, Volume und Snapshots.

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
files.revealFileQuery → Doneprograms.launch + files.ownohne Budget0x0003_000A
files.snapshotSnapshotQuery → SnapshotInfofiles.system≤ 50 µs0x0003_000C
files.takeSnapshotSnapshotQuery → SnapshotInfofiles.system≤ 50 ms0x0003_000D
files.deleteSnapshotSnapshotQuery → Donefiles.system≤ 50 ms0x0003_000E
files.restoreRestoreFile → Restoredfiles.system≤ 2 s0x0003_000F

SwiftFilesIn Files zeigen (programs.launch + files.own)

AufrufWas er tutShape-Aufruf · Zeitbudget
Zeigen
Files.reveal(_ path: Span<UInt8>) -> FileError?staticZeigt eine Datei des eigenen Ordners in Files (Web-Downloads; braucht programs.launch).ohne Budgetfiles.reveal0x0003_000A
Beispiel
_ = name.withUnsafeBufferPointer { Files.reveal(Span(_unsafeElements: $0)) }   // z. B. "downloads/x.pdf"
Muster (kurz, nicht aus einem Programm kopiert)

SwiftFilesSchnappschüsse, der Zeitschieber (files.system)

AufrufWas er tutShape-Aufruf · Zeitbudget
Schnappschüsse
Files.snapshot(after previous: UInt64) -> Snapshot?staticDer Snapshot nach previous (0: der älteste).≤ 50 µsfiles.snapshot0x0003_000C
Beispiel
while let next = Files.snapshot(after: previous) { list.append(next); previous = next.id }
aus apps/files (gekürzt)
Files.takeSnapshot() -> Result<UInt64, FileError>staticJetzt einen Snapshot nehmen (bleibt bis gelöscht).≤ 50 msfiles.takeSnapshot0x0003_000D
Beispiel
if case .success(let id) = Files.takeSnapshot() { kept = id }
Muster (kurz, nicht aus einem Programm kopiert)
Files.deleteSnapshot(_ id: UInt64) -> FileError?staticSnapshot löschen und nur von ihm belegten Platz freigeben.≤ 50 msfiles.deleteSnapshot0x0003_000E
Beispiel
if next.kind == .requested { _ = Files.deleteSnapshot(next.id) }
aus apps/slidercheck (gekürzt)
Wiederherstellen
Files.restore(_ path: Span<UInt8>, snapshot: UInt64) -> Result<(name: InlineArray<80, UInt8>, length: Int), FileError>staticDatei/Ordner aus einem Snapshot zurückkopieren; nichts wird überschrieben ("name (HH.MM).ext").≤ 2 sfiles.restore0x0003_000F
Beispiel
switch Files.restore(path.span.extracting(0..<length), snapshot: snapshots[shown].id) {
case .success(let restored): note(restored.name, restored.length)
case .failure(let error): problem = TextLine(error.text)
}
aus apps/files (gekürzt)
Alle 10 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
Files.Snapshot.var generation: UInt64
Files.Snapshot.var id: UInt64
Files.Snapshot.var kind
Files.Snapshot.var time: UInt64
Files.static func deleteSnapshot(_ id: UInt64) -> FileError?
Files.static func restore(_ path: Span<UInt8>, snapshot: UInt64) -> Result<(name: InlineArray<80, UInt8>, length: Int), FileError>
Files.static func reveal(_ path: Span<UInt8>) -> FileError?
Files.static func snapshot(after previous: UInt64) -> Snapshot?
Files.static func takeSnapshot() -> Result<UInt64, FileError>
Files.struct Snapshot

database · SOFTrobotsDB

Nur für Systemprogramme – nicht Teil der App-API, kann sich ändern

Jede Datenbank auf DATA schreiben, nicht nur die eigenen (das Programm Database: database.edit); die Regeln des Schemas gelten weiter für jede Zeile.

Was jedes Programm davon nutzen darf: App-API › database.

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
database.editJede Datenbank auf DATA schreiben, nicht nur die eigenen (Programm Database).≤ 1 msdatabase.write0x0004_0002

network · Netzwerk, TLS, Cloud-KI

Nur für Systemprogramme – nicht Teil der App-API, kann sich ändern

Verbindungen annehmen (nur das Programm Server: network.incoming und listens = …).

Was jedes Programm davon nutzen darf: App-API › network.

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
network.incomingVerbindungen auf den Ports der listens =-Zeile annehmen (Programm Server).≤ 50 µsnetwork.listen0x0005_000C

SystemaufrufenetworkModul 0x0005 · Netzwerk: Namen, TCP, UDP, Lauschen (get/post geplant).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
network.listenListen → Listeningnetwork.incoming≤ 50 µs0x0005_000C
network.acceptAccept → Acceptednetwork.incoming≤ 10 s0x0005_000D
network.listenerInfoListenerRequest → ListenerInfonetwork.incoming≤ 20 µs0x0005_000E
network.closeListenerListenerRequest → Donenetwork.incoming≤ 50 µs0x0005_000F

SwiftNetwork.Listener · Network.PeerEingehend (network.incoming)

AufrufWas er tutShape-Aufruf · Zeitbudget
Lauschen
Network.Listener.init?(port: UInt16, backlog: UInt8 = 8)Lauschen; nil wenn der Port nicht im Manifest steht, belegt ist oder Not-Halt gilt.≤ 50 µsnetwork.listen0x0005_000C
Beispiel
guard let listener = Network.Listener(port: 8080, backlog: 4) else { return }
aus apps/listencheck (gekürzt)
Network.Listener.close()Nicht mehr lauschen; angenommene Verbindungen bleiben.≤ 50 µsnetwork.closeListener0x0005_000F
Annehmen
Network.Listener.accept(timeout: UInt64 = 1_000_000_000) -> (connection: Network.Connection, peer: Network.Peer)?Nächste Verbindung annehmen.≤ 10 snetwork.accept0x0005_000D
Beispiel
if let (connection, peer) = listener.accept(timeout: 1_000_000_000) {
    // peer.ipv4 / peer.port; connection.send(...), connection.close()
}
Muster (kurz, nicht aus einem Programm kopiert)
Network.Peer: ipv4, ipv6, overIPv6, portWer sich verbunden hat.
Zustand
Network.Listener.info() -> ListenerInfo?Angenommen, abgelehnt, halb offen, wartend.≤ 20 µsnetwork.listenerInfo0x0005_000E
Alle 11 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
Network.Listener.func accept(timeout: UInt64 = 1_000_000_000) -> (connection: Network.Connection, peer: Network.Peer)?
Network.Listener.func close()
Network.Listener.func info() -> ListenerInfo?
Network.Listener.init?(port: UInt16, backlog: UInt8 = 8)
Network.Listener.let handle: ListenerHandle
Network.Peer.let ipv4: UInt32
Network.Peer.let ipv6: InlineArray<16, UInt8>
Network.Peer.let overIPv6: Bool
Network.Peer.let port: UInt16
Network.struct Listener
Network.struct Peer

ui · Fenster, Zeichnen, Views, Eingabe, Menüs, Fortschritt

Nur für Systemprogramme – nicht Teil der App-API, kann sich ändern

Den Bildschirm besitzen (der Display-Dienst: ui.display), Eingaben empfangen (ui.input, ein primitiver Systemaufruf) und liefern (Eingabe-Treiber: ui.input.provide).

Was jedes Programm davon nutzen darf: App-API › ui.

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
ui.displayDen Bildschirm besitzen (nur der Display-Dienst).≤ 5 msdisplay.open0x0011_0001
ui.input.provide / ui.inputEingabe-Ereignisse liefern (Treiber) bzw. empfangen (Display-Dienst).≤ 5 µsdisplay.submitInput0x0011_0006

SystemaufrufedisplayModul 0x0011 · Bildschirm und Fensterspeicher (ui.surface, ui.display).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
display.openDisplayQuery → ScreenInfoui.display≤ 5 ms0x0011_0001
display.flushPixelRect → Doneui.display≤ 200 µs0x0011_0002
display.screenshotDisplayQuery → Doneui.display≤ 50 ms0x0011_0003
display.surfaceSurfaceQuery → SurfaceStateui.display≤ 20 µs0x0011_0005
display.submitInputInputEvent → Doneui.input.provide≤ 5 µs0x0011_0006

SwiftScreenNur der Display-Dienst (ui.display)

AufrufWas er tutShape-Aufruf · Zeitbudget
Bildschirm
Screen.open() -> (canvas: Canvas, needsFlush: Bool)?staticÜbernimmt den Bildschirm.≤ 5 msdisplay.open0x0011_0001
Beispiel
guard let (screen, needsFlush) = Screen.open() else { return }   // nur mit ui.display
aus apps/display (gekürzt)
Screen.flush(_ rect: Rect)staticZeigt ein geändertes Rechteck (virtio-gpu).≤ 200 µsdisplay.flush0x0011_0002
Screen.saveScreenshot() -> BoolstaticSpeichert den Bildschirm als PNG in /data/screenshots.≤ 50 msdisplay.screenshot0x0011_0003
Fenster & Eingabe
Screen.surface(_ index: Int) -> SurfaceInfostaticFenster Nummer index aus Sicht des Dienstes.≤ 20 µsdisplay.surface0x0011_0005
Screen.input(into events: inout InlineArray<96, UInt64>) -> IntstaticEingabe-Ereignisse abholen.inputReceive (Systemaufruf 12)
Screen.wait(timeout: UInt64) / .notify(_ index: Int)staticAuf Programme warten / ein Fenster wecken.wait / surfaceNotify

SwiftSystemEingaben liefern (ui.input.provide)

AufrufWas er tutShape-Aufruf · Zeitbudget
Nur Display-Dienst und Treiber
System.submitInput(kind: UInt64, code: UInt64, value: UInt64)Eingabe-Ereignis liefern (ui.input.provide).≤ 5 µsdisplay.submitInput0x0011_0006
Alle 17 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
Screen.static func flush(_ rect: Rect)
Screen.static func input(into events: inout InlineArray<96, UInt64>) -> Int
Screen.static func notify(_ index: Int)
Screen.static func open() -> (canvas: Canvas, needsFlush: Bool)?
Screen.static func saveScreenshot() -> Bool
Screen.static func surface(_ index: Int) -> SurfaceInfo
Screen.static func wait(timeout: UInt64)
SurfaceInfo.var generation: UInt64
SurfaceInfo.var kind: UInt8
SurfaceInfo.var owner
SurfaceInfo.var pixels: UInt64
SurfaceInfo.var realtime
SurfaceInfo.var ring: UInt64
SurfaceInfo.var stride
System.static func submitInput(kind: UInt64, code: UInt64, value: UInt64)
enum Screen
struct SurfaceInfo

sound · Abspielen und Hören

Nur für Systemprogramme – nicht Teil der App-API, kann sich ändern

Die Gesamtlautstärke setzen (Settings: sound.volume), die MIC-Anzeige und ihr Stopp (Display-Dienst: system.protection) und ein Mikrofon anbieten (Test-Mikrofon: sound.microphone.provide).

Was jedes Programm davon nutzen darf: App-API › sound.

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
sound.volumeDie Gesamtlautstärke setzen.≤ 50 µssound.setVolume0x0030_0009
sound.microphone.provideEin Mikrofon anbieten (Test-Mikrofon).≤ 1 msmicrophone.provide0x0031_0006

SystemaufrufemicrophoneModul 0x0031 · Die Mikrofone des Roboters (sound.microphone, sound.microphone.provide).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
microphone.listenersListenersRequest → Listenerssystem.protection≤ 20 µs0x0031_0004
microphone.stopAllStopListening → Donesystem.protection≤ 1 ms0x0031_0005
microphone.provideProvideMicrophone → ProvidedMicrophonesound.microphone.provide≤ 1 ms0x0031_0006
microphone.pushPushSamples → Donesound.microphone.provide≤ 200 µs0x0031_0007

SystemaufrufesoundModul 0x0030 · Ton über den Mischer des Systems (sound.play; tone/play/stop geplant).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
sound.setVolumeMasterVolume → Donesound.volume≤ 50 µs0x0030_0009

SwiftSound.OutputGesamtlautstärke (sound.volume)

AufrufWas er tutShape-Aufruf · Zeitbudget
Lautstärke
Sound.Output.setMasterVolume(_ volume: Int) -> BoolstaticGesamtlautstärke setzen (sound.volume).≤ 50 µssound.setVolume0x0030_0009
Beispiel
_ = Sound.Output.setMasterVolume(70)   // nur mit sound.volume
Muster (kurz, nicht aus einem Programm kopiert)

SwiftSound.MicrophoneMIC-Anzeige (system.protection), Mikrofon anbieten (sound.microphone.provide)

AufrufWas er tutShape-Aufruf · Zeitbudget
Hörer (MIC-Anzeige)
Sound.Microphone.listeners(into names: inout InlineArray<512, UInt8>) -> (length: Int, count: Int)Wer gerade hört (MIC-Anzeige; system.protection).≤ 20 µsmicrophone.listeners0x0031_0004
Sound.Microphone.stopAll() -> BoolAlle Hörer stoppen (Stopp auf der MIC-Karte; system.protection).≤ 1 msmicrophone.stopAll0x0031_0005
Beispiel
_ = Sound.Microphone.stopAll()   // Stopp auf der MIC-Karte
aus apps/display (gekürzt)
Mikrofon anbieten
Sound.Microphone.provide(_ name: StaticString, channels: Int = 1) -> Int?Ein Mikrofon anbieten (sound.microphone.provide).≤ 1 msmicrophone.provide0x0031_0006
Beispiel
guard let microphone = Sound.Microphone.provide("Test microphone", channels: 1) else { return }
aus apps/testmicrophone (gekürzt)
Sound.Microphone.push(_ id: Int, samples: Int) -> Bool / .pushBuffer / .pushRoomProben aus pushBuffer einspeisen (höchstens 80 ms Stereo).≤ 200 µsmicrophone.push0x0031_0007
Alle 7 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
Sound.Microphone.static func listeners(into names: inout InlineArray<512, UInt8>) -> (length: Int, count: Int)
Sound.Microphone.static func provide(_ name: StaticString, channels: Int = 1) -> Int?
Sound.Microphone.static func push(_ id: Int, samples: Int) -> Bool
Sound.Microphone.static func stopAll() -> Bool
Sound.Microphone.static let pushRoom
Sound.Microphone.static var pushBuffer: UnsafeMutablePointer<Int16>
Sound.Output.static func setMasterVolume(_ volume: Int) -> Bool

camera · Kameras, Sehen und Erkennungen

Nur für Systemprogramme – nicht Teil der App-API, kann sich ändern

Eine Kamera anbieten und Bilder hineinschieben (Test-Kamera, USB-Treiber: camera.provide).

Was jedes Programm davon nutzen darf: App-API › camera.

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
camera.provideEine Kamera anbieten und Bilder hineinschieben (Test-Kamera).≤ 1 mscamera.provide0x0020_0007

SystemaufrufecameraModul 0x0020 · Die Kameras des Roboters (camera.use, camera.provide).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
camera.provideProvideCamera → ProvidedCameracamera.provide≤ 1 ms0x0020_0007
camera.pushPushFrame → Donecamera.provide≤ 500 µs0x0020_0008

SwiftCameraEine Kamera anbieten (camera.provide)

AufrufWas er tutShape-Aufruf · Zeitbudget
Kamera anbieten
Camera.provide(_ name: StaticString, width: Int, height: Int) -> Int?Anbieter einer Kamera werden (camera.provide).≤ 1 mscamera.provide0x0020_0007
Beispiel
guard let id = Camera.provide("Test camera", width: 640, height: 480) else { return }   // camera.provide
Muster (kurz, nicht aus einem Programm kopiert)
Camera.push(_ id: Int, count: Int) -> Bool / .frameBuffer / .frameRoomDas JPEG in frameBuffer (höchstens 448 KiB) als nächstes Bild einspeisen.≤ 500 µscamera.push0x0020_0008
Beispiel
// JPEG-Bytes nach Camera.frameBuffer kopieren (höchstens Camera.frameRoom), dann:
_ = Camera.push(id, count: jpeg.count)
Muster (kurz, nicht aus einem Programm kopiert)
Alle 4 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
Camera.static func provide(_ name: StaticString, width: Int, height: Int) -> Int?
Camera.static func push(_ id: Int, count: Int) -> Bool
Camera.static let frameRoom
Camera.static var frameBuffer: UnsafeMutableRawBufferPointer

robot · Arme, Kinematik, Aktor-Dienst, CAN

Nur für Systemprogramme – nicht Teil der App-API, kann sich ändern

Treiber für USB- und CAN-Controller (device.usb, device.can): Controller öffnen, DMA-Speicher, auf Interrupts warten.

Was jedes Programm davon nutzen darf: App-API › robot.

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
device.usb / device.canTreiber: Register eines USB- bzw. CAN-FD-Controllers einblenden, DMA-Speicher.≤ 1 msdevices.open0x0009_0001

SystemaufrufedevicesModul 0x0009 · Controller für Treiberprogramme (device.usb, device.can).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
devices.openControllerQuery → Controllerdevice.usb oder device.can≤ 1 ms0x0009_0001
devices.allocateDMARequest → DMAMemorydevice.usb≤ 1 ms0x0009_0002

SwiftSystemTreiber: Controller, DMA, Interrupts

AufrufWas er tutShape-Aufruf · Zeitbudget
Nur Display-Dienst und Treiber
System.openUSBController(_:) / .openCANController(_:) / .allocateDMA(_:) / .waitForDevice(timeout:)Treiber: Register, DMA-Speicher, Interrupts (device.usb, device.can).≤ 1 msdevices.open0x0009_0001
Alle 4 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
System.static func allocateDMA(_ size: UInt64) -> (UInt64, UInt64)?
System.static func openCANController(_ index: Int) -> UInt64?
System.static func openUSBController(_ index: Int) -> UInt64?
System.static func waitForDevice(timeout: UInt64) -> Bool

safety · Der Not-Halt

Nur für Systemprogramme – nicht Teil der App-API, kann sich ändern

Den Not-Halt auslösen und lösen (safety.stop) und Aktoren treiben (der Aktor-Dienst: safety.actuator; er wird bei einem Not-Halt sofort geweckt und muss die Aktoren sicher machen).

Was jedes Programm davon nutzen darf: App-API › safety.

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
safety.stopDen Not-Halt auslösen und lösen.≤ 20 µssafety.stop0x0100_0002
safety.actuatorAktoren treiben: bei Not-Halt sofort geweckt, muss sie sicher machen (Aktor-Dienst).

SystemaufrufesafetyModul 0x0100 · Der Not-Halt (lesen frei, stop/release mit safety.stop).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
safety.stopEmergencyStop → Donesafety.stop≤ 20 µs0x0100_0002
safety.releaseSafetyQuery → Donesafety.stop≤ 20 µs0x0100_0003

SwiftSystemNot-Halt auslösen und lösen (safety.stop)

AufrufWas er tutShape-Aufruf · Zeitbudget
Auslösen & lösen
System.emergencyStop(reason: UInt64) -> BoolAlle Aktoren sofort anhalten (safety.stop).≤ 20 µssafety.stop0x0100_0002
Beispiel
let stopped = System.emergencyStop(reason: 5)
aus apps/server (gekürzt)
System.releaseEmergencyStop() -> BoolHalt lösen; Aktoren warten auf den nächsten Befehl ihrer Programme.≤ 20 µssafety.release0x0100_0003
Beispiel
System.releaseEmergencyStop()
aus apps/arm (gekürzt)
Beispiel: Not-Halt im Aktor-Dienst beobachten (apps/actuators)
var safety = System.safetyGeneration
if safety & 1 == 1 { motors.emergencyStop(true) }
while true {
    let now = System.safetyGeneration
    if now != safety { motors.emergencyStop(now & 1 == 1); safety = now }
    // ...
}
Alle 2 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
System.static func emergencyStop(reason: UInt64) -> Bool
System.static func releaseEmergencyStop() -> Bool

clipboard · Kopieren und Einsetzen

Nur für Systemprogramme – nicht Teil der App-API, kann sich ändern

Einen Lesezugriff auf die Zwischenablage freigeben, wenn der Besitzer „Einsetzen“ gewählt hat (Display-Dienst: ui.display).

Was jedes Programm davon nutzen darf: App-API › clipboard.

Rechte

Kein eigenes Recht: das Freigeben braucht ui.display (Modul ui).

SystemaufrufeclipboardModul 0x0012 · Kopieren und Einsetzen.

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
clipboard.grantPasteGrant → Doneui.displayohne Budget0x0012_0003

SwiftClipboardFreigeben (Display-Dienst, ui.display)

AufrufWas er tutShape-Aufruf · Zeitbudget
Freigeben (Dienst)
Clipboard.grant(process slot: Int)staticGibt Programm slot einen Lesezugriff (nur der Display-Dienst).ohne Budgetclipboard.grant0x0012_0003
Beispiel
if id == EditMenu.paste { Clipboard.grant(process: windows[window].info.owner) }
aus apps/display (gekürzt)
Alle 1 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
Clipboard.static func grant(process slot: Int)

dialog · Öffnen und Sichern über das System

Nur für Systemprogramme – nicht Teil der App-API, kann sich ändern

Den Öffnen- und Sichern-Dialog zeigen und die Wahl melden (nur das Programm chooser: files.dialog).

Was jedes Programm davon nutzen darf: App-API › dialog.

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
files.dialog neuDen Öffnen-/Sichern-Dialog des Systems zeigen und die Wahl melden (nur Programm chooser).≤ 5 msdialog.answer0x0013_0004

SystemaufrufedialogModul 0x0013 · Öffnen- und Sichern-Dialog des Systems (neu, 10.11.).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
dialog.questions neuQuestionsRequest → DialogQuestionsfiles.dialog≤ 50 µs0x0013_0003
dialog.answer neuDialogAnswer → Donefiles.dialog≤ 5 ms0x0013_0004

SystemaufrufedialogNur das Systemprogramm chooser (files.dialog)

AufrufWas er tutShape-Aufruf · Zeitbudget
Nur mit files.dialog
dialog.questions neuOffene Fragen aller Programme (der chooser zeigt sie).≤ 50 µsdialog.questions0x0013_0003
dialog.answer neuDie Wahl der Person für Frage number; der Kern prüft Ort und Typ, fragt „Ersetzen?“.≤ 5 msdialog.answer0x0013_0004
Beispiel: Der Datei-Dialog selbst: nie im Dock (apps/chooser/manifest)
name = chooser
id = de.softrobots.chooser
title = File Dialog
category = system
capabilities = system.log, ui.surface, files.system, files.dialog
kind = system
start = demand
helper = display
# Never in the dock, not even while a dialog is open (2026-11-10).
dock = no

update · Systemupdates

Nur für Systemprogramme – nicht Teil der App-API, kann sich ändern

Signierte Systemupdates in die ruhende Systemkopie installieren, Startbild und Startton wählen (Settings, Update: system.update).

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
system.updateSignierte Systemupdates in die ruhende Systemkopie installieren.≤ 60 supdate.install0x0008_0002

SystemaufrufeupdateModul 0x0008 · Systemkopien A/B und Updates (system.update).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
update.statusUpdateQuery → UpdateStatesystem.update≤ 5 µs0x0008_0001
update.installUpdatePackage → Donesystem.update≤ 60 s0x0008_0002
update.textStartStartLook → Donesystem.update≤ 50 ms0x0008_0003
update.startSoundStartSound → Donesystem.update≤ 50 ms0x0008_0004

SwiftSystemUpdates (system.update)

AufrufWas er tutShape-Aufruf · Zeitbudget
Updates (system.update)
System.updateStatus() -> UpdateStatus?Welche Systemkopie (A/B) läuft, Probelauf, Rückfall, Versionen.≤ 5 µsupdate.status0x0008_0001
System.installUpdate(_ path: Span<UInt8>) -> UpdateResultSigniertes Paket in die ruhende Kopie installieren; startet nach dem Neustart.≤ 60 supdate.install0x0008_0002
System.setTextStart(_ text: Bool) -> Bool / System.setStartSound(_ on: Bool) -> BoolTextstart statt Animation / Startton.≤ 50 msupdate.textStart0x0008_0003
Alle 18 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
System.static func installUpdate(_ path: Span<UInt8>) -> UpdateResult
System.static func setStartSound(_ on: Bool) -> Bool
System.static func setTextStart(_ text: Bool) -> Bool
System.static func updateStatus() -> UpdateStatus?
UpdateStatus.var active
UpdateStatus.var installing
UpdateStatus.var onTrial
UpdateStatus.var rolledBack
UpdateStatus.var running
UpdateStatus.var startSound
UpdateStatus.var textStart
UpdateStatus.var trial: Int?
UpdateStatus.var triesLeft
UpdateStatus.var unsupported
UpdateStatus.var versionA
UpdateStatus.var versionB
enum UpdateResult
struct UpdateStatus

protection · Geräteschutz

Nur für Systemprogramme – nicht Teil der App-API, kann sich ändern

Geräteschutz: Passwort für DATA, Entsperren, Bildschirmsperre, Wahl des Besitzers (nur der Display-Dienst: system.protection).

Rechte

RechtBedeutungShape-Aufruf · Zeitbudget
system.protectionGeräteschutz: Passwort, Entsperren, Bildschirmsperre, MIC-Anzeige (nur Display-Dienst).≤ 5 µsprotection.status0x0007_0001

SystemaufrufeprotectionModul 0x0007 · Geräteschutz: Passwort für DATA, Sperre, Besitzerwahl (system.protection).

AufrufAnfrage → AntwortRechtZeitbudget · Kennung
protection.statusProtectionQuery → ProtectionStatussystem.protection≤ 5 µs0x0007_0001
protection.setUpPassword → RecoveryKeysystem.protection≤ 3 s0x0007_0002
protection.unlockPassword → Donesystem.protection≤ 3 s0x0007_0003
protection.verifyPassword → Donesystem.protection≤ 3 s0x0007_0004
protection.choicesProtectionQuery → OwnerChoicessystem.protection≤ 2 ms0x0007_0005

SwiftSystemNur der Display-Dienst (system.protection)

AufrufWas er tutShape-Aufruf · Zeitbudget
Nur Display-Dienst und Treiber
System.protectionStatus() / .protectionSetUp / .protectionCheck / .ownerChoices()Geräteschutz und Besitzerwahl (system.protection).≤ 5 µsprotection.status0x0007_0001
Alle 5 Deklarationen dieses Teils (aus docs/api/app-api-1.txt)
System.enum ProtectionResult
System.static func ownerChoices() -> (lockMinutes: Int?, appearance: Appearance, dock: InlineArray<160, UInt8>, dockCount: Int, buddy: Int)
System.static func protectionCheck<let n: Int>(_ password: InlineArray<n, UInt8>, count: Int, unlock: Bool) -> ProtectionResult
System.static func protectionSetUp<let n: Int>(_ password: InlineArray<n, UInt8>, count: Int,
System.static func protectionStatus() -> (state: ProtectionState, development: Bool, wait: Int)

Bibliotheken

Werkzeuge, die ein Programm benutzen kann, ohne dass sie mit dem System reden: sie kommen mit einer Profil-Datei uses-… in den Programmordner und werden mitgebaut. Sie haben ihre eigene Liste (docs/api/libraries.txt, 874 Deklarationen, tools/api/symbols.py --libraries) und werden zu 1.0 nicht eingefroren – sie dürfen sich weiterentwickeln.

Übersicht

BibliothekWofürDateiDeklarationen
webWeb: HTML, CSS, HTTPuses-web279
imageBilder und PDFuses-image173
svgSVGuses-svg105
soundTon: Werkzeuge und Formateuses-heap118
archiveArchive: ZIP, Deflateuses-archive79
sqlSQLuses-sql52
mathsMathematikjedes Profil25
videoVideo: VP9uses-video25
qrQR-Codesuses-qr10
opusOpususes-opus8

web · Web: HTML, CSS, HTTP

HTML lesen (Baum, Tokenizer), CSS auswerten (Selektoren, Kaskade, Längen, Medien), HTTP-Anfragen und -Antworten, URLs – die Grundlage des Programms Web.

Quelle: userland/web/ · Datei uses-web · 279 Deklarationen

Alle 279 Deklarationen der Bibliothek (docs/api/libraries.txt)
CSSAttributeTest.var ignoreCase: Bool
CSSAttributeTest.var name: String
CSSAttributeTest.var op: UInt8
CSSAttributeTest.var value: String
CSSCompound.var attributes: [CSSAttributeTest]
CSSCompound.var classes: [String]
CSSCompound.var id
CSSCompound.var pseudos: [CSSPseudo]
CSSCompound.var tag
CSSDeclaration.var important: Bool
CSSDeclaration.var name: String
CSSDeclaration.var value: String
CSSDisplay.var isInlineLevel: Bool
CSSLength.func resolve(_ base: Double) -> Double
CSSLength.init(px: Double = 0, percent: Double = 0, kind: UInt8 = 0)
CSSLength.static func pixels(_ value: Double) -> CSSLength
CSSLength.static let auto
CSSLength.var isAuto: Bool
CSSLength.var isLength: Bool
CSSLength.var isNone: Bool
CSSLength.var kind: UInt8
CSSLength.var percent: Double
CSSLength.var px: Double
CSSMedia.static func matches(_ query: String, _ viewport: CSSViewport) -> Bool
CSSParser.static func declarations(_ text: String) -> [CSSDeclaration]
CSSParser.static func parse(_ text: String, viewport: CSSViewport) -> CSSStyleSheet
CSSParser.static let limit
CSSRule.var declarations: [CSSDeclaration]
CSSRule.var selectors: [CSSSelector]
CSSSelector.static func parse(_ text: String) -> CSSSelector?
CSSSelector.var combinators: [UInt8]
CSSSelector.var compounds: [CSSCompound]
CSSSelector.var pseudoElement
CSSSelector.var specificity
CSSSelector.var subject: CSSCompound
CSSStyle.func border(_ side: Int) -> Double
CSSStyle.func inherited() -> CSSStyle
CSSStyle.init()
CSSStyle.mutating func apply(_ name: String, _ rawValue: String, parent: CSSStyle, units: CSSUnits)
CSSStyle.var alignItems
CSSStyle.var alignSelf
CSSStyle.var aspectRatio
CSSStyle.var background
CSSStyle.var basis
CSSStyle.var borderBox
CSSStyle.var borderColor
CSSStyle.var borderSpacing
CSSStyle.var borderStyleSet
CSSStyle.var borderWidth
CSSStyle.var captionBottom
CSSStyle.var clear: UInt8
CSSStyle.var clipsOverflow
CSSStyle.var collapseBorders
CSSStyle.var color
CSSStyle.var columnGap
CSSStyle.var condensed
CSSStyle.var display
CSSStyle.var family
CSSStyle.var flexDirection: UInt8
CSSStyle.var flexWrap
CSSStyle.var float
CSSStyle.var fontSize
CSSStyle.var fontWeight
CSSStyle.var gridArea
CSSStyle.var gridAreas: [[String]]
CSSStyle.var gridColumnSpan
CSSStyle.var gridColumnStart
CSSStyle.var gridColumns: [CSSLength]
CSSStyle.var grow
CSSStyle.var height
CSSStyle.var inset
CSSStyle.var invisibleBox
CSSStyle.var italic
CSSStyle.var justifyContent
CSSStyle.var lineHeight
CSSStyle.var lineHeightPixels
CSSStyle.var lineThrough
CSSStyle.var listStyle
CSSStyle.var margin
CSSStyle.var masked
CSSStyle.var maxHeight
CSSStyle.var maxWidth
CSSStyle.var minHeight
CSSStyle.var minWidth
CSSStyle.var objectFit: UInt8
CSSStyle.var order
CSSStyle.var padding
CSSStyle.var position
CSSStyle.var rowGap
CSSStyle.var scrollsOverflow
CSSStyle.var shrink
CSSStyle.var textAlign
CSSStyle.var textIndent
CSSStyle.var transform
CSSStyle.var underline
CSSStyle.var usedLineHeight: Double
CSSStyle.var variables
CSSStyle.var verticalAlign
CSSStyle.var visible
CSSStyle.var whiteSpace
CSSStyle.var width
CSSStyleSheet.init()
CSSStyleSheet.var imports: [String]
CSSStyleSheet.var rules: [CSSRule]
CSSUnits.init(fontSize: Double, rootFontSize: Double, viewport: CSSViewport)
CSSUnits.var fontSize: Double
CSSUnits.var rootFontSize: Double
CSSUnits.var viewport: CSSViewport
CSSValue.static func color(_ text: String, current: RGBA) -> RGBA?
CSSValue.static func length(_ text: String, _ units: CSSUnits, allowAuto: Bool = true) -> CSSLength?
CSSValue.static func mediaLength(_ text: String) -> Double?
CSSValue.static func number(_ text: String) -> Double?
CSSValue.static func parts(_ value: String) -> [String]
CSSValue.static func substitute(_ value: String, _ variables: [String: String], depth: Int = 0) -> String?
CSSValue.static func substitute(_ value: String, lookup: (String) -> String?, depth: Int = 0) -> String?
CSSValue.static func url(_ text: String) -> String?
CSSVariables.func lookup(_ name: String, from scope: Int) -> String?
CSSVariables.private(set) var parents: [Int]
CSSVariables.private(set) var tables: [[String: String]]
CSSViewport.init(width: Int, height: Int)
CSSViewport.var height: Int
CSSViewport.var width: Int
Charset.static func utf8(_ bytes: [UInt8], charset: String) -> [UInt8]
DefaultStyle.static let css
ElementTree.func matches(_ compound: CSSCompound, _ node: Int) -> Bool
ElementTree.func matches(_ selector: CSSSelector, _ node: Int) -> Bool
ElementTree.init(_ document: HTMLDocument)
ElementTree.let document: HTMLDocument
ElementTree.private(set) var classes: [[String]]
ElementTree.private(set) var ids: [String]
ElementTree.private(set) var parent: [Int32]
ElementTree.private(set) var position: [Int32]
ElementTree.private(set) var previous: [Int32]
ElementTree.private(set) var siblings: [Int32]
GlyphImage.var coverage: [UInt8]
GlyphImage.var left
HTMLDocument.init()
HTMLDocument.private(set) var baseHref: String?
HTMLDocument.private(set) var nodes: [HTMLNode]
HTMLDocument.private(set) var styleSources: [StyleSource]
HTMLDocument.private(set) var styles: [String]
HTMLDocument.private(set) var title
HTMLDocument.private(set) var truncated
HTMLDocument.static func parse(_ bytes: [UInt8]) -> HTMLDocument
HTMLDocument.static let html
HTMLDocument.static let maxDepth
HTMLDocument.static let maxNodes
HTMLNode.func attribute(_ name: String) -> String?
HTMLNode.var attributes: [(name: String, value: String)]
HTMLNode.var children: [Int]
HTMLNode.var parent: Int
HTMLNode.var tag: String
HTMLNode.var text: String
HTMLTokenizer.init(_ bytes: [UInt8])
HTMLTokenizer.mutating func next() -> HTMLToken?
HTMLTokenizer.mutating func rawText(until name: String) -> String
HTMLTokenizer.static func decode(_ text: String) -> String
HTTPRequest.static func get(_ url: WebURL) -> [UInt8]
HTTPRequest.static func get(_ url: WebURL, from offset: Int) -> [UInt8]
HTTPRequest.static func post(_ url: WebURL, body: [UInt8]) -> [UInt8]
HTTPRequest.static let userAgent
HTTPResponse.enum State: Equatable
HTTPResponse.func header(_ name: String) -> String?
HTTPResponse.init()
HTTPResponse.mutating func completeDownload(_ whole: [UInt8])
HTTPResponse.mutating func feed(_ bytes: Span<UInt8>) -> State
HTTPResponse.mutating func finish()
HTTPResponse.private(set) var body: [UInt8]
HTTPResponse.private(set) var headers: [(name: String, value: String)]
HTTPResponse.private(set) var leftover
HTTPResponse.private(set) var state
HTTPResponse.private(set) var status
HTTPResponse.static let limit
HTTPResponse.var charset: String
HTTPResponse.var contentType: String
HTTPResponse.var expectedLength: Int?
HTTPResponse.var isRedirect: Bool
HTTPResponse.var reusable: Bool
OutlineFont.func advance(_ glyph: Int) -> Int
OutlineFont.func glyph(_ code: UInt32) -> Int?
OutlineFont.func kerning(_ first: UInt32, _ second: UInt32) -> Double
OutlineFont.func outline(_ index: Int, _ body: (_ command: Int, _ x: Int, _ y: Int, _ cx: Int, _ cy: Int) -> Void)
OutlineFont.func render(_ index: Int, size: Double, slant: Double = 0, stretch: Double = 1) -> GlyphImage
OutlineFont.init(unitsPerEm: Int, ascent: Int, descent: Int, lineGap: Int, codes: StaticString, offsets: StaticString, data: StaticString,
OutlineFont.init(unitsPerEm: Int, ascent: Int, descent: Int, lineGap: Int, codes: [UInt8], offsets: [UInt8], data: [UInt8],
OutlineFont.let ascent: Int
OutlineFont.let descent: Int
OutlineFont.let lineGap: Int
OutlineFont.let unitsPerEm: Int
OutlineFont.var glyphCount: Int
PageMemory.Entry.var body: [UInt8]
PageMemory.Entry.var contentType: String
PageMemory.func entry(_ address: String) -> Entry?
PageMemory.init()
PageMemory.mutating func forget(_ address: String)
PageMemory.mutating func keep(_ address: String, body: [UInt8], contentType: String, noStore: Bool)
PageMemory.private(set) var bytes
PageMemory.static func forbids(cacheControl: String?) -> Bool
PageMemory.static let budget
PageMemory.struct Entry
PageMemory.var count: Int
RGBA.init(_ r: UInt8, _ g: UInt8, _ b: UInt8, _ a: UInt8 = 255)
RGBA.static let black
RGBA.var r: UInt8, g: UInt8, b: UInt8, a: UInt8
ResolvedStyles.init()
ResolvedStyles.var after: [Int: (text: String, style: CSSStyle)]
ResolvedStyles.var before: [Int: (text: String, style: CSSStyle)]
ResolvedStyles.var canvas
ResolvedStyles.var styles: [CSSStyle]
ResolvedStyles.var variables
Sides.init(_ values: [T])
Sides.init(repeating value: T)
Sides.subscript(_ side: Int) -> T
Sides.var top: T, right: T, bottom: T, left: T
String.func collapsingSpaces() -> String
String.func hasSubstring(_ part: String) -> Bool
StyleResolver.static func resolve(_ document: HTMLDocument, sheets: [CSSStyleSheet], viewport: CSSViewport) -> ResolvedStyles
StyleSource.var href: String?
StyleSource.var media: String
StyleSource.var text: String
WebURL.init(scheme: String, host: String, port: Int? = nil, path: String, query: String? = nil, fragment: String? = nil)
WebURL.static func parse(_ text: String) -> WebURL?
WebURL.static let start
WebURL.var fragment: String?
WebURL.var host: String
WebURL.var path: String
WebURL.var port: Int?
WebURL.var query: String?
WebURL.var scheme: String
enum CSSAlign: UInt8
enum CSSAlignment: UInt8
enum CSSDisplay: UInt8
enum CSSFamily: UInt8
enum CSSFloat: UInt8
enum CSSListStyle: UInt8
enum CSSMedia
enum CSSParser
enum CSSPosition: UInt8
enum CSSTransform: UInt8
enum CSSValue
enum CSSVerticalAlign: UInt8
enum CSSWhiteSpace: UInt8
enum Charset
enum DefaultStyle
enum HTMLToken
enum HTTPRequest
enum StyleResolver
func resolve(_ reference: String) -> WebURL?
indirect enum CSSPseudo
static func percentEncoded(_ text: String) -> String
static func search(_ words: String) -> WebURL
struct CSSAttributeTest
struct CSSCompound
struct CSSDeclaration
struct CSSLength: Equatable, Sendable
struct CSSRule
struct CSSSelector
struct CSSStyle
struct CSSStyleSheet
struct CSSUnits
struct CSSVariables
struct CSSViewport
struct ElementTree
struct GlyphImage: Sendable
struct HTMLDocument
struct HTMLNode
struct HTMLTokenizer
struct HTTPResponse
struct OutlineFont: Sendable
struct PageMemory
struct RGBA: Equatable, Sendable
struct ResolvedStyles
struct Sides<T>
struct StyleSource
struct WebURL: Equatable, Sendable
var effectivePort: Int
var requestTarget: String
var secure: WebURL
var text: String

image · Bilder und PDF

Mit uses-image (braucht uses-heap): Bilder dekodieren und kodieren, PDF schreiben und lesen. Ein Picture hält RGBA-Pixel. PDF lesen ist ungeprüfte Eingabe – die Programme Reader und Image lesen deshalb nur das eine Dokument, das ihnen übergeben wurde. QR-Codes mit uses-qr (ohne Heap).

Container und Codecs für Aufnahme und Wiedergabe: Matroska/WebM (uses-image), VP9 (uses-video), Opus (uses-opus), WAV und FLAC (mit uses-heap). Camera nimmt MKV mit MJPEG, Ton und Erkennungen auf; Video spielt MKV und WebM (VP9 + Opus).

Quelle: userland/image/ · Datei uses-image · 173 Deklarationen

SwiftPictureEin Bild

AufrufWas er tutShape-Aufruf · Zeitbudget
Bild
Picture(width: Int = 0, height: Int = 0, pixels: [UInt8] = [], scale: Int = 1)Ein Bild aus RGBA-Pixeln.
Beispiel
var picture = Picture(width: 64, height: 48, pixels: [UInt8](repeating: 255, count: 64 * 48 * 4))
aus apps/apicheck (gekürzt)
Picture.maxFile / .maxPixelsstaticGrenzen gegen zu große Eingaben.
PictureError.textKurzer Satz für Meldungen.
Dekodieren
Picture.decode(_ file: [UInt8]) -> Result<Picture, PictureError>staticPNG, JPEG, GIF, WebP, BMP oder TIFF nach Signatur.
Beispiel
guard case .success(let picture) = Picture.decode(Array(jpeg[0..<taken.count])) else { return false }
aus apps/video (gekürzt)

SwiftPNG · JPEG · GIF · WebP · BMP · TIFFFormate

AufrufWas er tutShape-Aufruf · Zeitbudget
PNG & JPEG
PNG.encode(_ picture: Picture) -> [UInt8]? / .decode / .hasSignature / .size(_:)PNG verlustfrei (RGB wenn deckend, sonst RGBA); Größe ohne Dekodieren.
Beispiel
guard let png = PNG.encode(picture), case .success(let decodedPNG) = PNG.decode(png) else { return }
aus apps/apicheck (gekürzt)
JPEG.encode(_ picture: Picture, quality: Int = 85) -> [UInt8]? / .decode / .hasSignatureJPEG (Baseline, 4:2:0, Qualität 1 … 100).
Beispiel
guard let jpeg = JPEG.encode(picture, quality: 85) else { return }
aus apps/apicheck (gekürzt)
GIF & WebP
GIF.decode / .hasSignature / .maxFramesGIF, erstes Bild.
GIFAnimation.parse(_ file: [UInt8]) -> Result<GIFAnimation, PictureError>Animiertes GIF: advance(), show(_:), delay(_:), frameCount, pixels.
Beispiel
guard case .success(var animation) = GIFAnimation.parse(bytes) else { return }
let wait = animation.advance()   // ms bis zum nächsten Bild; animation.pixels zeigen
Muster (kurz, nicht aus einem Programm kopiert)
WebP.decode / .hasSignatureWebP (verlustbehaftet und verlustfrei).
WebPAnimation.parse(_ file: [UInt8]) -> Result<WebPAnimation, PictureError>Animiertes WebP, wie GIFAnimation.
BMP & TIFF
BMP.encode / .decode / .hasSignature, TIFF.encode / .decode / .hasSignatureBMP und TIFF lesen und schreiben.
Entpacken & Senken
Inflater.zlib(_:limit:) / .zlib(_:size:) / .gzip(_:limit:)zlib/gzip entpacken (mit Größengrenze).
PNGSink / ByteCollector (ByteSink)Ziele für Bytes beim Kodieren.

SwiftPDFDocumentPDF schreiben

AufrufWas er tutShape-Aufruf · Zeitbudget
Dokument
PDFDocument(width: Double = PDFDocument.a4.width, height: Double = PDFDocument.a4.height)Neues Dokument (Maße in Punkt).
Beispiel
var pdf = PDFDocument()   // A4
aus apps/image (gekürzt)
PDFDocument.newPage() / .data() -> [UInt8]Neue Seite / das fertige PDF.
Beispiel
pdf.newPage()
let bytes = pdf.data()   // dann Files.Handle.open(…, mode: .replace) und write
Muster (kurz, nicht aus einem Programm kopiert)
PDFDocument.data(userPassword: [UInt8], ownerPassword: [UInt8], random: [UInt8]) -> [UInt8]Verschlüsseltes PDF.
Inhalt setzen
PDFDocument.text(_ text: String, x: Double, y: Double, size: Double = 11, font: Font = .regular, colour: (UInt8, UInt8, UInt8) = (0, 0, 0))Text setzen.
Beispiel
pdf.text(name.isEmpty ? "Picture" : name, x: margin, y: margin + 14, size: 16, font: .bold)
aus apps/image (gekürzt)
PDFDocument.picture(_ picture: Picture, x:y:width:height:, jpeg: [UInt8]? = nil) -> BoolBild einsetzen (optional das JPEG direkt).
PDFDocument.line(x0:y0:x1:y1:width:colour:) / .rectangle(x:y:width:height:fill:)Linie, gefülltes Rechteck.
Maße
PDFDocument.width(_ text: String, size: Double, font: Font = .regular) -> Double / .a4staticTextbreite, A4-Maße.

SwiftPDFReaderPDF lesen

AufrufWas er tutShape-Aufruf · Zeitbudget
Öffnen
PDFReader.init(_ bytes: [UInt8], password: [UInt8] = []) throws(PDFReadError)Öffnet ein PDF (auch verschlüsselt).
Beispiel
var opened = try PDFReader(fileBytes, password: password)
aus apps/reader (gekürzt)
Seiten & Text
PDFReader.pageCount / .page(_ index: Int) -> PDFPage?Seiten (width, height, rotate, content, resources).
Beispiel
guard var reader = try? PDFReader(bytes), let page = reader.page(0) else { return }
aus apps/files (gekürzt)
PDFReader.text(page index: Int) -> [PDFTextRun]Textstücke einer Seite mit Lage und Größe.
Navigation
PDFReader.outline() / .links(page:)Inhaltsverzeichnis, Links.
Beispiel
outlineItems = opened.outline()   // [(level, title, page)]
aus apps/reader (gekürzt)
Rohdaten & Rechte
PDFReader.object / .resolve / .streamBytes / .decode / .decodeBytes / .trailerRohe Objekte für eigene Auswertung (PDFObject, PDFDictionary).
PDFReader.isEncrypted / .openedAsOwner / .permissions / .textString(_:) / .maximumFile / .maximumStreamVerschlüsselung, Rechte, Grenzen.

SwiftMatroskaWriterMKV schreiben (MJPEG, Ton, Erkennungen)

AufrufWas er tutShape-Aufruf · Zeitbudget
Anlegen
MatroskaWriter.init(width: Int, height: Int, detections: Bool = false, soundRate: Int = 0, soundChannels: Int = 1)Neuer Schreiber.
MatroskaWriter.header(app: StaticString = "") -> [UInt8]Kopf der Datei.
Spuren schreiben
MatroskaWriter.frame(_ jpeg: [UInt8], milliseconds: Int) -> [UInt8]Ein Bild.
MatroskaWriter.sound(_ samples: [UInt8], milliseconds: Int) -> [UInt8]Ein Stück Ton.
MatroskaWriter.detections(_ text: [UInt8], milliseconds: Int) -> [UInt8]Erkennungen als Untertitelspur.
Abschließen
MatroskaWriter.finish() -> [UInt8] / .frames / .lastTimeAbschluss (Index).

SwiftMatroskaIndex · MatroskaTrack · MatroskaFrameMKV/WebM lesen

AufrufWas er tutShape-Aufruf · Zeitbudget
Lesen & springen
MatroskaIndex(size: Int, read: @escaping (Int, Int) -> [UInt8]) throws(MatroskaError)Liest die Struktur über eine Lesefunktion (ohne alles zu laden).
Beispiel
guard let index = try? MatroskaIndex(size: Int(size), read: reader) else { return }
aus apps/video (gekürzt)
MatroskaIndex.tracks / .frames / .duration / .docType / .seek(_ milliseconds: Int, track: Int) -> IntSpuren, Rahmen (track, time, offset, length, key), Springen.
Spuren
MatroskaTrack.isCodec(_ name: StaticString) -> Bool / .codec / .codecPrivate / .sampleRate / .widthCodec einer Spur ("V_VP9", "A_OPUS").
Beispiel
opus = track.isCodec("A_OPUS") ? OpusDecoder(head: track.codecPrivate) : nil
aus apps/video (gekürzt)
MatroskaID.ebml / .cluster / .tracks / .cues …Element-IDs.
Beispiel: Fenster als PNG oder JPEG sichern (sdk-apps/about)
guard let bytes = jpeg ? JPEG.encode(picture, quality: 90) : PNG.encode(picture),
      case .success(let file) = jpeg ? Files.Handle.open("window.jpg", mode: .replace) : Files.Handle.open("window.png", mode: .replace) else {
    saved = TextLine("Could not save the picture")
    return
}
bytes.withUnsafeBufferPointer { buffer in _ = file.write(Span(_unsafeElements: buffer)) }
_ = file.close()
Beispiel: Ein Bild als PDF ausgeben (apps/image)
var pdf = PDFDocument()
let margin = 40.0
pdf.text(name.isEmpty ? "Picture" : name, x: margin, y: margin + 14, size: 16, font: .bold)
pdf.text(String(shown.width) + " x " + String(shown.height) + " pixels · SOFTrobots OS Image",
         x: margin, y: margin + 32, size: 10, colour: (110, 110, 110))
_ = pdf.picture(shown, x: margin, y: margin + 50, width: 400, height: 300)
let bytes = pdf.data()
Beispiel: PDF öffnen und Seiten lesen (apps/reader)
do {
    var opened = try PDFReader(fileBytes, password: password)
    for index in 0..<opened.pageCount {
        if let page = opened.page(index) {
            let turned = page.rotate == 90 || page.rotate == 270
            pageSizes.append(turned ? (page.height, page.width) : (page.width, page.height))
        }
    }
    let runs = opened.text(page: 0)     // [PDFTextRun]: text, x, y, size, width
} catch {
    // falsches Passwort, beschädigt …
}
Beispiel: Aufnahme als MKV beginnen und Bilder anhängen (apps/video, Recording.swift)
guard case .success(let file) = Files.Handle.open(path, mode: .replace) else { return false }
var writer = MatroskaWriter(width: picture.width * picture.scale, height: picture.height * picture.scale, detections: true,
                            soundRate: recordSoundFormat.rate, soundChannels: recordSoundFormat.channels)
let header = writer.header()
_ = header.withUnsafeBufferPointer { file.write(Span(_unsafeElements: $0)) }

// je Kamerabild:
let milliseconds = Int((System.time &- recordStarted) / 1_000_000)
let piece = writer.frame(Array(jpeg[0..<jpegCount]), milliseconds: milliseconds)
_ = piece.withUnsafeBufferPointer { file.write(Span(_unsafeElements: $0)) }
Alle 173 Deklarationen der Bibliothek (docs/api/libraries.txt)
BMP.static func decode(_ file: [UInt8]) -> Result<Picture, PictureError>
BMP.static func encode(_ picture: Picture) -> [UInt8]?
BMP.static func hasSignature(_ file: [UInt8]) -> Bool
GIF.static func decode(_ file: [UInt8]) -> Result<Picture, PictureError>
GIF.static func hasSignature(_ file: [UInt8]) -> Bool
GIF.static let maxFrames
GIFAnimation.func delay(_ frame: Int) -> Int
GIFAnimation.let height: Int
GIFAnimation.let loopCount: Int
GIFAnimation.let width: Int
GIFAnimation.mutating func advance() -> Int
GIFAnimation.mutating func show(_ target: Int)
GIFAnimation.private(set) var index
GIFAnimation.private(set) var pixels: [UInt8]
GIFAnimation.static func parse(_ file: [UInt8]) -> Result<GIFAnimation, PictureError>
GIFAnimation.var frameCount: Int
HuffmanCode.mutating func build(_ lengths: [UInt8], _ start: Int, _ count: Int) -> Bool
HuffmanCode.static let fastBits
HuffmanCode.var counts
HuffmanCode.var fast
HuffmanCode.var symbols
Inflater.static func gzip(_ input: [UInt8], limit: Int) -> Result<[UInt8], InflateError>
Inflater.static func zlib(_ input: [UInt8], limit: Int) -> Result<[UInt8], InflateError>
Inflater.static func zlib(_ input: [UInt8], size: Int) -> Result<[UInt8], InflateError>
JPEG.static func decode(_ file: [UInt8]) -> Result<Picture, PictureError>
JPEG.static func encode(_ picture: Picture, quality: Int = 85) -> [UInt8]?
JPEG.static func hasSignature(_ file: [UInt8]) -> Bool
MatroskaFrame.var key: Bool
MatroskaFrame.var length: Int
MatroskaFrame.var offset: Int
MatroskaFrame.var time: Int
MatroskaFrame.var track: Int
MatroskaID.static let audio
MatroskaID.static let bitDepth
MatroskaID.static let cluster
MatroskaID.static let codecID
MatroskaID.static let cueClusterPosition
MatroskaID.static let cues
MatroskaID.static let ebml
MatroskaID.static let timestampScale
MatroskaID.static let tracks
MatroskaIndex.func seek(_ milliseconds: Int, track: Int) -> Int
MatroskaIndex.init(size: Int, read: @escaping (Int, Int) -> [UInt8]) throws(MatroskaError)
MatroskaIndex.private(set) var docType: [UInt8]
MatroskaIndex.private(set) var duration
MatroskaIndex.private(set) var frames: [MatroskaFrame]
MatroskaIndex.private(set) var tracks: [MatroskaTrack]
MatroskaTrack.func isCodec(_ name: StaticString) -> Bool
MatroskaTrack.var codec: [UInt8]
MatroskaTrack.var codecDelay
MatroskaTrack.var codecPrivate: [UInt8]
MatroskaTrack.var number
MatroskaTrack.var sampleRate
MatroskaTrack.var type
MatroskaTrack.var width
MatroskaWriter.init(width: Int, height: Int, detections: Bool = false, soundRate: Int = 0, soundChannels: Int = 1)
MatroskaWriter.mutating func detections(_ text: [UInt8], milliseconds: Int) -> [UInt8]
MatroskaWriter.mutating func finish() -> [UInt8]
MatroskaWriter.mutating func frame(_ jpeg: [UInt8], milliseconds: Int) -> [UInt8]
MatroskaWriter.mutating func header(app: StaticString = "") -> [UInt8]
MatroskaWriter.mutating func sound(_ samples: [UInt8], milliseconds: Int) -> [UInt8]
MatroskaWriter.private(set) var frames
MatroskaWriter.private(set) var lastTime
PDFDictionary.init()
PDFDictionary.subscript(_ key: StaticString) -> PDFObject?
PDFDictionary.var keys: [[UInt8]]
PDFDictionary.var values: [PDFObject]
PDFDocument.enum Font: Int
PDFDocument.init(width: Double = PDFDocument.a4.width, height: Double = PDFDocument.a4.height)
PDFDocument.let width: Double, height: Double
PDFDocument.mutating func data() -> [UInt8]
PDFDocument.mutating func data(userPassword: [UInt8], ownerPassword: [UInt8], random: [UInt8]) -> [UInt8]
PDFDocument.mutating func line(x0: Double, y0: Double, x1: Double, y1: Double, width w: Double = 0.5, colour: (UInt8, UInt8, UInt8) = (0, 0, 0))
PDFDocument.mutating func newPage()
PDFDocument.mutating func picture(_ picture: Picture, x: Double, y: Double, width w: Double, height h: Double, jpeg: [UInt8]? = nil) -> Bool
PDFDocument.mutating func rectangle(x: Double, y: Double, width w: Double, height h: Double, fill: (UInt8, UInt8, UInt8))
PDFDocument.mutating func text(_ text: String, x: Double, y: Double, size: Double = 11, font: Font = .regular,
PDFDocument.static func width(_ text: String, size: Double, font: Font = .regular) -> Double
PDFDocument.static let a4
PDFObject.func isName(_ text: StaticString) -> Bool
PDFObject.var array: [PDFObject]?
PDFObject.var bytes: [UInt8]?
PDFObject.var dictionary: PDFDictionary?
PDFObject.var integer: Int?
PDFObject.var name: [UInt8]?
PDFObject.var number: Double?
PDFPage.var content: [UInt8]
PDFPage.var height: Double
PDFPage.var originX: Double
PDFPage.var originY: Double
PDFPage.var resources: PDFDictionary
PDFPage.var rotate: Int
PDFPage.var width: Double
PDFReader.init(_ bytes: [UInt8], password: [UInt8] = []) throws(PDFReadError)
PDFReader.mutating func decode(_ dictionary: PDFDictionary, _ start: Int, _ length: Int) -> [UInt8]?
PDFReader.mutating func decodeBytes(_ input: [UInt8], _ dictionary: PDFDictionary) -> [UInt8]?
PDFReader.mutating func links(page index: Int) -> [(x: Double, y: Double, width: Double, height: Double, page: Int, uri: [UInt8])]
PDFReader.mutating func object(_ number: Int, depth: Int = 0) -> PDFObject?
PDFReader.mutating func outline() -> [(level: Int, title: [UInt8], page: Int)]
PDFReader.mutating func page(_ index: Int) -> PDFPage?
PDFReader.mutating func resolve(_ value: PDFObject, depth: Int = 0) -> PDFObject
PDFReader.mutating func streamBytes(_ value: PDFObject) -> [UInt8]?
PDFReader.mutating func text(page index: Int) -> [PDFTextRun]
PDFReader.private(set) var isEncrypted
PDFReader.private(set) var openedAsOwner
PDFReader.private(set) var permissions: UInt32
PDFReader.private(set) var trailer
PDFReader.static func textString(_ bytes: [UInt8]) -> [UInt8]
PDFReader.static let maximumFile
PDFReader.static let maximumStream
PDFReader.var pageCount: Int
PDFTextRun.var size: Double
PDFTextRun.var text: [UInt8]
PDFTextRun.var width: Double
PDFTextRun.var x: Double
PDFTextRun.var y: Double
PNG.static func decode(_ file: [UInt8]) -> Result<Picture, PictureError>
PNG.static func encode(_ picture: Picture) -> [UInt8]?
PNG.static func hasSignature(_ file: [UInt8]) -> Bool
PNG.static func size(_ file: [UInt8]) -> (width: Int, height: Int)?
PNGSink.mutating func write(_ data: Span<UInt8>) -> Bool
PNGSink.var bytes
Picture.init(width: Int = 0, height: Int = 0, pixels: [UInt8] = [], scale: Int = 1)
Picture.static func decode(_ file: [UInt8]) -> Result<Picture, PictureError>
Picture.static let maxFile
Picture.static let maxPixels
Picture.var height
Picture.var pixels: [UInt8]
Picture.var scale
Picture.var width
PictureError.var text: StaticString
TIFF.static func decode(_ file: [UInt8]) -> Result<Picture, PictureError>
TIFF.static func encode(_ picture: Picture) -> [UInt8]?
TIFF.static func hasSignature(_ file: [UInt8]) -> Bool
WebP.static func decode(_ file: [UInt8]) -> Result<Picture, PictureError>
WebP.static func hasSignature(_ file: [UInt8]) -> Bool
WebPAnimation.func delay(_ frame: Int) -> Int
WebPAnimation.let height: Int
WebPAnimation.let loopCount: Int
WebPAnimation.let width: Int
WebPAnimation.mutating func advance()
WebPAnimation.mutating func show(_ target: Int)
WebPAnimation.private(set) var index
WebPAnimation.private(set) var pixels: [UInt8]
WebPAnimation.static func parse(_ file: [UInt8]) -> Result<WebPAnimation, PictureError>
WebPAnimation.var frameCount: Int
enum BMP
enum GIF
enum InflateError: UInt8, Error
enum JPEG
enum MatroskaError: Error, Equatable
enum MatroskaID
enum PDFObject
enum PDFReadError: Error, Equatable
enum PNG
enum PictureError: UInt8, Error
enum TIFF
enum WebP
struct GIFAnimation
struct HuffmanCode
struct Inflater
struct MatroskaFrame
struct MatroskaIndex
struct MatroskaTrack
struct MatroskaWriter
struct PDFDictionary
struct PDFDocument
struct PDFPage
struct PDFReader
struct PDFTextRun
struct PNGSink: ByteSink
struct Picture
struct WebPAnimation

svg · SVG

SVG lesen und zeichnen: Dokument, Pfade, Matrizen, Farben, Schriften, auf eine Canvas oder in ein Bild.

Quelle: userland/svg/ · Datei uses-svg · 105 Deklarationen

Alle 105 Deklarationen der Bibliothek (docs/api/libraries.txt)
PDFCharacter.var run: Int
PDFCharacter.var text: [UInt8]
PDFCharacter.var x: Double, y: Double, width: Double, height: Double
PDFRender.static func characters(_ reader: inout PDFReader, _ index: Int, scale: Double) -> [PDFCharacter]
PDFRender.static func page(_ reader: inout PDFReader, _ index: Int, scale: Double, maximumPixels: Int = 40_000_000) -> SVGCanvas?
SVGCanvas.func straightRGBA() -> [UInt8]
SVGCanvas.init(width: Int, height: Int)
SVGCanvas.let height: Int
SVGCanvas.let width: Int
SVGCanvas.var pixels: [UInt8]
SVGColor.init(_ r: Float, _ g: Float, _ b: Float, _ a: Float = 1)
SVGColor.static func parse(_ raw: String) -> SVGColor?
SVGColor.static let black
SVGColor.static let transparent
SVGColor.var r: Float, g: Float, b: Float, a: Float
SVGDocument.func text(of index: Int) -> String
SVGDocument.init()
SVGDocument.private(set) var ids: [String: Int]
SVGDocument.private(set) var nodes: [SVGNode]
SVGDocument.private(set) var styles: [String]
SVGDocument.static func build(root: Int, _ element: (Int) -> (name: String, attributes: [(name: String, value: String)], children: [Int], text: String))
SVGDocument.static func parse(_ bytes: [UInt8]) -> Result<SVGDocument, SVGError>
SVGDocument.static let maxDepth
SVGDocument.static let maxNodes
SVGFonts.init(sans: OutlineFont? = nil, bold: OutlineFont? = nil, mono: OutlineFont? = nil, serif: OutlineFont? = nil)
SVGFonts.var bold: OutlineFont?
SVGFonts.var mono: OutlineFont?
SVGFonts.var sans: OutlineFont?
SVGFonts.var serif: OutlineFont?
SVGImage.func render(width: Int, height: Int) -> SVGCanvas
SVGImage.func render(width: Int, height: Int, sceneWidth: Double, sceneHeight: Double, x: Double, y: Double) -> SVGCanvas
SVGImage.func renderRGBA(width: Int, height: Int) -> [UInt8]
SVGImage.init(_ document: SVGDocument)
SVGImage.let intrinsicHeight: Double
SVGImage.let intrinsicWidth: Double
SVGImage.nonisolated(unsafe) static var fonts
SVGImage.nonisolated(unsafe) static var loadFonts: (() -> SVGFonts)?
SVGImage.static func parse(_ bytes: [UInt8]) -> Result<SVGImage, SVGError>
SVGImage.static let maxDrawn
SVGImage.static let maxSide
SVGImage.var currentColor: SVGColor?
SVGLength.enum Unit: Sendable
SVGLength.func resolve(_ reference: Double, fontSize: Double) -> Double
SVGLength.init(_ value: Double, _ unit: Unit)
SVGLength.static func parse(_ text: String) -> SVGLength?
SVGLength.var unit: Unit
SVGLength.var value: Double
SVGMatrix.func apply(_ x: Double, _ y: Double) -> (Double, Double)
SVGMatrix.func multiplied(_ m: SVGMatrix) -> SVGMatrix
SVGMatrix.init()
SVGMatrix.init(_ a: Double, _ b: Double, _ c: Double, _ d: Double, _ e: Double, _ f: Double)
SVGMatrix.static func rotate(_ degrees: Double) -> SVGMatrix
SVGMatrix.static func scale(_ x: Double, _ y: Double) -> SVGMatrix
SVGMatrix.static func skewX(_ degrees: Double) -> SVGMatrix
SVGMatrix.static func skewY(_ degrees: Double) -> SVGMatrix
SVGMatrix.static func translate(_ x: Double, _ y: Double) -> SVGMatrix
SVGMatrix.static let identity
SVGMatrix.var a
SVGMatrix.var inverse: SVGMatrix?
SVGMatrix.var scaleFactor: Double
SVGNode.func attribute(_ name: String) -> String?
SVGNode.init(name: String, attributes: [(name: String, value: String)] = [], parent: Int = -1, children: [Int] = [], text: String = "")
SVGNode.var attributes: [(name: String, value: String)]
SVGNode.var children: [Int]
SVGNode.var name: String
SVGNode.var parent: Int
SVGNode.var text: String
SVGNumberScanner.init(_ text: String)
SVGNumberScanner.mutating func number() -> Double?
SVGNumberScanner.mutating func unit() -> String
SVGNumberScanner.var atEnd: Bool
SVGPath.func bounds() -> (Double, Double, Double, Double)?
SVGPath.func flattened(tolerance: Double) -> [SVGPolyline]
SVGPath.func transformed(_ m: SVGMatrix) -> SVGPath
SVGPath.init()
SVGPath.init(_ segments: [SVGSegment])
SVGPath.static func ellipse(cx: Double, cy: Double, rx: Double, ry: Double) -> SVGPath
SVGPath.static func line(_ x1: Double, _ y1: Double, _ x2: Double, _ y2: Double) -> SVGPath
SVGPath.static func parse(_ data: String) -> SVGPath
SVGPath.static func poly(_ text: String, closed: Bool) -> SVGPath
SVGPath.static func rect(x: Double, y: Double, width: Double, height: Double, rx rIn: Double, ry rYIn: Double) -> SVGPath
SVGPath.var isEmpty: Bool
SVGPath.var segments: [SVGSegment]
SVGPolyline.var closed
SVGPolyline.var points: [(Double, Double)]
enum PDFRender
enum SVGError: Error, Equatable, Sendable
enum SVGFillRule: Sendable
enum SVGLineCap: Sendable
enum SVGLineJoin: Sendable
enum SVGPaintFallback: Equatable, Sendable
enum SVGPaintValue: Equatable, Sendable
enum SVGSegment: Equatable, Sendable
struct PDFCharacter
struct SVGCanvas: Sendable
struct SVGColor: Equatable, Sendable
struct SVGDocument: Sendable
struct SVGFonts: Sendable
struct SVGImage: Sendable
struct SVGLength: Equatable, Sendable
struct SVGMatrix: Equatable, Sendable
struct SVGNode: Sendable
struct SVGNumberScanner
struct SVGPath: Sendable
struct SVGPolyline: Sendable

sound · Ton: Werkzeuge und Formate

Abspielen (sound.play): jedes Programm bekommt einen Ring, den der Mischer des Kerns spielt (48 kHz, Stereo, Int16). Hören (sound.microphone): der Kern schreibt, was ein Mikrofon hört, in einen Ring pro Mikrofon (48 kHz, 16 Bit, mono/stereo, etwa 1,4 s), lesend in jedes hörende Programm eingeblendet; der Pegel jeder 10-ms-Periode steht daneben. Das Mikrofon läuft nur, solange jemand hört; die rote MIC-Anzeige nennt jedes Programm, und der Besitzer kann alle stoppen. Die Werkzeuge (Pegel, Auto-Pegel, Rauschtor, Stimmerkennung, Schnitt) kommen mit uses-heap.

Quelle: userland/sound/ · Datei uses-heap · 118 Deklarationen

SwiftLevelMeter · AutoLevel · NoiseGate · VoiceDetector · SoundEditPegel, Dynamik, Stimme, Schnitt

AufrufWas er tutShape-Aufruf · Zeitbudget
Pegel
LevelMeter.measure(_ samples: Span<Int16>) -> SoundLevelRMS und Spitze in dBFS.
Beispiel
let level = LevelMeter.measure(span)   // level.peak, level.rms in dBFS
aus apps/sound (gekürzt)
LevelMeter.periods(_ samples: Span<Int16>, channels: Int = 1) -> [SoundLevel]Pegel je 10-ms-Periode.
LevelMeter.decibels / .amplitude / .linear / .floor / .fullScaleUmrechnungen dB ↔ Amplitude.
Dynamik
AutoLevel(target: Double = -12, minimumGain: -12, maximumGain: 24, silence: -55, ceiling: -1, channels: 1, gain: 0)Automatische Verstärkung mit Begrenzer; process(&samples).
Beispiel
autoLevel = AutoLevel(channels: channels, gain: Double(choices.gain))
autoLevel.process(&span)
aus apps/sound (gekürzt)
NoiseGate(threshold: Double = -50, holdMilliseconds: 200, fadeMilliseconds: 5, channels: 1)Rauschtor; process(&samples), isOpen.
Beispiel
gate = NoiseGate(channels: channels)
gate.process(&span)
aus apps/sound (gekürzt)
Stimme
VoiceDetector(margin: 10, minimumLevel: -65, crossings: 0.004...0.25, hangoverMilliseconds: 300, channels: 1, noiseFloor: nil)Spricht jemand? detect(period) -> Bool, level, noiseFloor.
Beispiel
voice = VoiceDetector(channels: channels)
speaking = voice.detect(span)
aus apps/sound (gekürzt)
VoiceDetector.voiceParts(_ samples: [Int16], channels: Int = 1, gapMilliseconds: Int = 300, shortestMilliseconds: Int = 200) -> [Range<Int>]Sprechstellen einer Aufnahme.
Beispiel
voiceParts = VoiceDetector.voiceParts(sound.samples, channels: sound.channels)
aus apps/sound (gekürzt)
Aufnahme & Schnitt
PreRecordBuffer(seconds: Int = 5, channels: Int = 1): append / .drain / .clear / .framesDie letzten Sekunden vor dem Aufnahmestart.
Beispiel
preRecord = PreRecordBuffer(seconds: 5, channels: channels)
preRecord.append(span)            // jede Periode
let before = preRecord.drain()    // beim Aufnahmestart
aus apps/sound (gekürzt)
SoundEdit.trim / .trimSilenceEnds / .splitAtPauses / .normalize / .voiceBounds / .overviewSchneiden, Stille kürzen, an Pausen teilen, normalisieren, Wellenbild.
Beispiel
let samples = SoundEdit.trimSilenceEnds(sound.samples, channels: sound.channels)
let parts = SoundEdit.splitAtPauses(sound.samples, channels: sound.channels)
aus apps/sound (gekürzt)
OverviewBuilder(framesPerColumn:channels:reserveSeconds:): append / .overview(columns:)Wellenbild laufend aufbauen (WaveColumn min/max).
Format
SoundFormat.rate / .periodFrames / .frames(milliseconds:)48 kHz, 480 Frames pro 10 ms.

SwiftWAV · FLACWAV lesen, FLAC schreiben und lesen

AufrufWas er tutShape-Aufruf · Zeitbudget
WAV
WAV(_ file: Span<UInt8>)Liest einen WAV-Kopf: rate, channels, bits, float, frames, dataStart, milliseconds.
Beispiel
} else if let wav = head.withUnsafeBufferPointer({ WAV(Span(_unsafeElements: $0)) }) {
aus apps/sound (gekürzt)
WAV.render(_ file: Span<UInt8>, from first: Int, count: Int, into out: UnsafeMutablePointer<Int16>) -> Int / .sample(_:_:_:)Frames als Int16 (Stereo 48 kHz für Sound.Output).
FLAC schreiben
FLACEncoder(rate: Int, channels: Int, bits: Int, blockSize: Int = 4096, maxLPCOrder: Int = 12)FLAC-Kodierer.
Beispiel
let encoder = FLACEncoder(rate: rate, channels: channels, bits: 16)
file.pending = encoder.header()
aus apps/sound (gekürzt)
FLACEncoder.header() / .encode(_ samples: Span<Int16> | Span<Int32>) -> [UInt8] / .finish()Kopf, Blöcke, Abschluss (mit endgültigem Kopf).
FLAC lesen
FLACDecoder(_ data: [UInt8]) / .init(length:read:) throws(FLACError)FLAC lesen (ganz oder über eine Lesefunktion).
Beispiel
if var decoder = try? FLACDecoder(flac) {
    while let block = try? decoder.nextBlock(), !block.isEmpty { for value in block { decoded.append(Int16(truncatingIfNeeded: value)) } }
}
aus apps/miccheck (gekürzt)
FLACDecoder.nextBlock() throws(FLACError) -> [Int32] / .seek(toSample:) / .info: FLACInfoNächster Block, Springen, Stream-Infos (rate, channels, bits, totalSamples, md5).
Beispiel: FLAC-Datei schreiben (apps/sound, SoundFile.swift)
var encoder = FLACEncoder(rate: rate, channels: channels, bits: 16)
pending = encoder.header()
// je 10-ms-Periode:
pending += encoder.encode(samples)          // Span<Int16>
// am Ende:
let (tail, finalHeader) = encoder.finish()
Alle 118 Deklarationen der Bibliothek (docs/api/libraries.txt)
AutoLevel.init(target: Double = -12, minimumGain: Double = -12, maximumGain: Double = 24, silence: Double = -55,
AutoLevel.let ceiling: Double
AutoLevel.let channels: Int
AutoLevel.let maximumGain: Double
AutoLevel.let minimumGain: Double
AutoLevel.let silence: Double
AutoLevel.let target: Double
AutoLevel.mutating func process(_ samples: inout MutableSpan<Int16>)
AutoLevel.private(set) var gain: Double
AutoLevel.private(set) var limit
AutoLevel.var reduction: Double
FLACDecoder.init(_ data: [UInt8]) throws(FLACError)
FLACDecoder.init(length: Int, read: @escaping (_ offset: Int, _ count: Int) -> [UInt8]) throws(FLACError)
FLACDecoder.mutating func nextBlock() throws(FLACError) -> [Int32]
FLACDecoder.mutating func seek(toSample sample: Int) throws(FLACError)
FLACDecoder.private(set) var info: FLACInfo
FLACDecoder.private(set) var position
FLACEncoder.func header() -> [UInt8]
FLACEncoder.init(rate: Int, channels: Int, bits: Int, blockSize: Int = 4096, maxLPCOrder: Int = 12)
FLACEncoder.let bits: Int
FLACEncoder.let blockSize: Int
FLACEncoder.let channels: Int
FLACEncoder.let rate: Int
FLACEncoder.mutating func encode(_ samples: Span<Int16>) -> [UInt8]
FLACEncoder.mutating func encode(_ samples: Span<Int32>) -> [UInt8]
FLACEncoder.mutating func finish() -> (tail: [UInt8], finalHeader: [UInt8])
FLACInfo.init(rate: Int, channels: Int, bits: Int, totalSamples: Int = 0, minBlock: Int = 4096, maxBlock: Int = 4096,
FLACInfo.var bits: Int
FLACInfo.var channels: Int
FLACInfo.var maxBlock: Int
FLACInfo.var maxFrame: Int
FLACInfo.var md5: [UInt8]
FLACInfo.var minBlock: Int
FLACInfo.var minFrame: Int
FLACInfo.var rate: Int
FLACInfo.var totalSamples: Int
LevelMeter.static func amplitude(_ decibels: Double) -> Double
LevelMeter.static func decibels(_ amplitude: Double) -> Double
LevelMeter.static func linear(_ decibels: Double) -> Double
LevelMeter.static func measure(_ samples: Span<Int16>) -> SoundLevel
LevelMeter.static func periods(_ samples: Span<Int16>, channels: Int = 1) -> [SoundLevel]
LevelMeter.static let floor
LevelMeter.static let fullScale
NoiseGate.init(threshold: Double = -50, holdMilliseconds: Int = 200, fadeMilliseconds: Int = 5, channels: Int = 1)
NoiseGate.let channels: Int
NoiseGate.let fadeFrames: Int
NoiseGate.let holdFrames: Int
NoiseGate.let threshold: Double
NoiseGate.mutating func process(_ samples: inout MutableSpan<Int16>)
NoiseGate.private(set) var isOpen
OverviewBuilder.func overview(columns count: Int) -> [WaveColumn]
OverviewBuilder.init(framesPerColumn: Int = SoundFormat.periodFrames, channels: Int = 1, reserveSeconds: Int = 600)
OverviewBuilder.let channels: Int
OverviewBuilder.let framesPerColumn: Int
OverviewBuilder.mutating func append(_ period: Span<Int16>)
OverviewBuilder.private(set) var columns: [WaveColumn]
OverviewBuilder.private(set) var frames
OverviewBuilder.var allColumns: [WaveColumn]
PreRecordBuffer.init(seconds: Int = 5, channels: Int = 1)
PreRecordBuffer.let capacity: Int
PreRecordBuffer.let channels: Int
PreRecordBuffer.mutating func append(_ period: Span<Int16>)
PreRecordBuffer.mutating func clear()
PreRecordBuffer.mutating func drain() -> [Int16]
PreRecordBuffer.mutating func drain(into output: inout [Int16])
PreRecordBuffer.var frames: Int
SoundEdit.static func normalize(_ samples: [Int16], channels: Int = 1, peak: Double = -1) -> [Int16]
SoundEdit.static func overview(_ samples: [Int16], channels: Int = 1, columns: Int) -> [WaveColumn]
SoundEdit.static func splitAtPauses(_ samples: [Int16], channels: Int = 1, minimumPartMilliseconds: Int = 2000,
SoundEdit.static func trim(_ samples: [Int16], channels: Int = 1, from: Int, to: Int) -> [Int16]
SoundEdit.static func trimSilenceEnds(_ samples: [Int16], channels: Int = 1, paddingMilliseconds: Int = 50) -> [Int16]
SoundEdit.static func voiceBounds(_ samples: [Int16], channels: Int = 1, paddingMilliseconds: Int = 50) -> Range<Int>?
SoundFormat.static func frames(milliseconds: Int) -> Int
SoundFormat.static let periodFrames
SoundFormat.static let rate
SoundLevel.init(rms: Double, peak: Double)
SoundLevel.var peak: Double
SoundLevel.var rms: Double
VoiceDetector.init(margin: Double = 10, minimumLevel: Double = -65, crossings: ClosedRange<Double> = 0.004...0.25,
VoiceDetector.let channels: Int
VoiceDetector.let crossings: ClosedRange<Double>
VoiceDetector.let hangoverPeriods: Int
VoiceDetector.let margin: Double
VoiceDetector.let minimumLevel: Double
VoiceDetector.mutating func detect(_ period: Span<Int16>) -> Bool
VoiceDetector.private(set) var heard
VoiceDetector.private(set) var level
VoiceDetector.private(set) var noiseFloor
VoiceDetector.static func voiceParts(_ samples: [Int16], channels: Int = 1, gapMilliseconds: Int = 300,
WAV.func render(_ file: Span<UInt8>, from first: Int, count: Int, into out: UnsafeMutablePointer<Int16>) -> Int
WAV.func sample(_ file: Span<UInt8>, _ frame: Int, _ channel: Int) -> Int32
WAV.init?(_ file: Span<UInt8>)
WAV.let bits: Int
WAV.let channels: Int
WAV.let dataStart: Int
WAV.let float: Bool
WAV.let frames: Int
WAV.let rate: Int
WAV.var milliseconds: Int
WAV.var outputFrames: Int
WaveColumn.init(min: Int16, max: Int16)
WaveColumn.var max: Int16
WaveColumn.var min: Int16
enum FLACError: Error, Equatable
enum LevelMeter
enum SoundEdit
enum SoundFormat
struct AutoLevel
struct FLACDecoder
struct FLACEncoder
struct FLACInfo: Equatable
struct NoiseGate
struct OverviewBuilder
struct PreRecordBuffer
struct SoundLevel: Equatable
struct VoiceDetector
struct WAV
struct WaveColumn: Equatable

archive · Archive: ZIP, Deflate

Mit uses-archive (braucht uses-heap): ZIP lesen und schreiben; ein Passwort bedeutet immer WinZip AES-256. Dazu rohes DEFLATE und CRC32.

Quelle: userland/archive/ · Datei uses-archive · 79 Deklarationen

SwiftZipArchive · ZipEntryLesen

AufrufWas er tutShape-Aufruf · Zeitbudget
Inhalt lesen
ZipArchive.entries<S: ByteSource>(_ source: inout S) -> Result<[ZipEntry], ZipError>Inhaltsverzeichnis lesen.
Beispiel
var source = bytesSource            // ein ByteSource über die Datei
guard case .success(let entries) = ZipArchive.entries(&source) else { return }
Muster (kurz, nicht aus einem Programm kopiert)
ZipEntry: name, size, compressedSize, crc, isDirectory, isEncrypted, isLink, method, aes…Ein Eintrag.
Entpacken
ZipArchive.extract(_ entries: [ZipEntry], from source: S, to destination: inout D, password: [UInt8]?) -> Result<ZipSummary, ZipError>Einträge entpacken (ZipSummary: files, folders, bytes, skipped).
ZipArchive.safePath(_ entry: ZipEntry) -> [UInt8]?Sicherer Pfad (kein „..“, kein absoluter Pfad).

SwiftZipWriterSchreiben

AufrufWas er tutShape-Aufruf · Zeitbudget
Schreiben
ZipWriter.beginFile(_ file: Span<UInt8>, time: ZipTime, password: [UInt8]?, salt: Span<UInt8>, _ sink: inout Sink) -> Result<Void, ZipError>Datei beginnen (mit Passwort: AES-256).
ZipWriter.write(_ data: Span<UInt8>, _ sink: inout Sink) / .endFile(_:) / .addFolder(_:time:_:) / .finish(_:)Daten, Dateiende, Ordner, Abschluss.
Zeit
ZipTime(unixSeconds: Int64, offsetSeconds: Int64)Zeitstempel.

SwiftDeflater · StreamInflater · CRC32Deflate & Prüfsummen

AufrufWas er tutShape-Aufruf · Zeitbudget
Deflate & Prüfsummen
Deflater.compress(_:_:) / .finish(_:) / .reset()Rohes DEFLATE packen.
StreamInflater.next(_ source: inout S) -> Result<Range<Int>?, InflateError> / .reset() / .totalRohes DEFLATE stückweise entpacken.
CRC32.add(_ bytes: Span<UInt8>) / .checksum / .reset()CRC-32.
Beispiel
var crc = CRC32()
crc.add(data.span)
let sum = crc.checksum
Muster (kurz, nicht aus einem Programm kopiert)
Alle 79 Deklarationen der Bibliothek (docs/api/libraries.txt)
ByteCollector.mutating func write(_ data: Span<UInt8>) -> Bool
ByteCollector.var bytes
CRC32.func step(_ crc: UInt32, _ byte: UInt8) -> UInt32
CRC32.init()
CRC32.mutating func add(_ bytes: Span<UInt8>)
CRC32.mutating func reset()
CRC32.var checksum: UInt32
Deflater.init()
Deflater.mutating func compress<Sink: ByteSink>(_ data: Span<UInt8>, _ sink: inout Sink) -> Bool
Deflater.mutating func finish<Sink: ByteSink>(_ sink: inout Sink) -> Bool
Deflater.mutating func reset()
Deflater.static func canonicalCodes(_ lengths: [UInt8], _ count: Int) -> [UInt16]
Deflater.static func huffmanLengths(_ frequencies: [UInt32], _ count: Int, limit: Int) -> [UInt8]
Deflater.static let distanceBase: InlineArray<30, UInt16>
Deflater.static let distanceExtra: InlineArray<30, UInt8>
Deflater.static let lengthBase: InlineArray<29, UInt16>
Deflater.static let lengthExtra: InlineArray<29, UInt8>
StreamInflater.init()
StreamInflater.mutating func next<S: ByteSource>(_ source: inout S) -> Result<Range<Int>?, InflateError>
StreamInflater.mutating func reset()
StreamInflater.private(set) var total: UInt64
StreamInflater.static let flushAt
StreamInflater.static let history
ZipArchive.static func entries<S: ByteSource>(_ source: inout S) -> Result<[ZipEntry], ZipError>
ZipArchive.static func extract<S: ByteSource, D: ZipDestination>(_ entries: [ZipEntry], from source: S, to destination: inout D,
ZipArchive.static func safePath(_ entry: ZipEntry) -> [UInt8]?
ZipEntry.var aesMethod: UInt16
ZipEntry.var aesStrength: UInt8
ZipEntry.var aesVersion: UInt16
ZipEntry.var compressedSize: UInt64
ZipEntry.var crc: UInt32
ZipEntry.var dosTime: UInt32
ZipEntry.var external: UInt32
ZipEntry.var flags: UInt16
ZipEntry.var isDirectory: Bool
ZipEntry.var isEncrypted: Bool
ZipEntry.var isLink: Bool
ZipEntry.var madeBy: UInt16
ZipEntry.var method: UInt16
ZipEntry.var name: [UInt8]
ZipEntry.var offset: UInt64
ZipEntry.var size: UInt64
ZipError.var text: StaticString
ZipInput.init(source: S)
ZipInput.mutating func bytes(_ wanted: Int) -> [UInt8]?
ZipInput.mutating func read(into out: inout [UInt8]) -> Int
ZipInput.mutating func skip(to target: UInt64) -> Bool
ZipInput.var failure: ZipError
ZipInput.var remaining: UInt64
ZipInput.var source: S
ZipSummary.var bytes: UInt64
ZipSummary.var files
ZipSummary.var folders
ZipSummary.var skipped
ZipTime.init()
ZipTime.init(unixSeconds: Int64, offsetSeconds: Int64)
ZipTime.var dos: UInt32
ZipTime.var unix: UInt32
ZipWriter.init()
ZipWriter.mutating func addFolder<Sink: ByteSink>(_ folder: Span<UInt8>, time: ZipTime, _ sink: inout Sink) -> Result<Void, ZipError>
ZipWriter.mutating func beginFile<Sink: ByteSink>(_ file: Span<UInt8>, time: ZipTime, password: [UInt8]?, salt: Span<UInt8>,
ZipWriter.mutating func endFile<Sink: ByteSink>(_ sink: inout Sink) -> Result<Void, ZipError>
ZipWriter.mutating func finish<Sink: ByteSink>(_ sink: inout Sink) -> Result<Void, ZipError>
ZipWriter.mutating func write<Sink: ByteSink>(_ data: Span<UInt8>, _ sink: inout Sink) -> Result<Void, ZipError>
ZipWriter.var written: UInt64
enum ZipArchive
enum ZipError: UInt8, Error
protocol ByteSink
protocol ByteSource
protocol ZipDestination
struct ByteCollector: ByteSink
struct CRC32
struct Deflater
struct StreamInflater
struct ZipEntry
struct ZipInput<S: ByteSource>: ByteSource
struct ZipSummary
struct ZipTime
struct ZipWriter

sql · SQL

SQL-Anweisungen in die Abfragen und Schreibsätze von SOFTrobotsDB übersetzen (SQL.translate, ausgeführt mit Database.next(query:aggregate:grouped:into:)); dazu die Beschreibung der Tabellen.

Quelle: userland/sql/ · Datei uses-sql · 52 Deklarationen

Alle 52 Deklarationen der Bibliothek (docs/api/libraries.txt)
DatabaseDescription.static func enumValue(_ description: Span<UInt8>, _ field: DescribedField, _ text: Span<UInt8>, _ start: Int, _ length: Int) -> Int?
DatabaseDescription.static func field(_ description: Span<UInt8>, _ table: DescribedTable, named text: Span<UInt8>, _ start: Int, _ length: Int) -> Int?
DatabaseDescription.static func table(_ description: Span<UInt8>, _ index: Int) -> DescribedTable?
DatabaseDescription.static func table(_ description: Span<UInt8>, named name: Span<UInt8>) -> (index: Int, table: DescribedTable)?
DatabaseDescription.static func tableCount(_ description: Span<UInt8>) -> Int
DatabaseDescription.static func withEnumName<R>(_ description: Span<UInt8>, _ field: DescribedField, _ value: Int, _ body: (Span<UInt8>) -> R) -> R?
DescribedField.init()
DescribedField.var enumCount: Int
DescribedField.var enumStart: Int
DescribedField.var flags: UInt8
DescribedField.var isFloat: Bool
DescribedField.var isOptional: Bool
DescribedField.var isSigned: Bool
DescribedField.var isText: Bool
DescribedField.var isUnique: Bool
DescribedField.var isVariable: Bool
DescribedField.var maximum: Int
DescribedField.var nameLength: Int
DescribedField.var nameStart: Int
DescribedField.var reference: Int
DescribedField.var size: Int
DescribedField.var type: UInt8
DescribedTable.init()
DescribedTable.var fieldCount
DescribedTable.var fields
DescribedTable.var indexCount
DescribedTable.var indexFields
DescribedTable.var indexLengths
DescribedTable.var nameLength
DescribedTable.var nameStart
SQL.static func lookup(_ description: Span<UInt8>, table index: Int, field: Int, id: UInt64,
SQL.static func translate(_ text: Span<UInt8>, _ description: Span<UInt8>,
SQLError.var message: StaticString
SQLError.var position: Int
SQLStatement.init()
SQLStatement.var aggregate
SQLStatement.var aggregateField
SQLStatement.var columnCount
SQLStatement.var columns
SQLStatement.var group
SQLStatement.var hasJoins: Bool
SQLStatement.var joinField
SQLStatement.var joinInner
SQLStatement.var joinTable
SQLStatement.var length
SQLStatement.var table
enum DatabaseDescription
enum SQL
struct DescribedField
struct DescribedTable
struct SQLError: Error
struct SQLStatement

maths · Mathematik

Ohne Heap braucht es feste Bausteine: TextLine ist eine Zeile fester Größe (160 Bytes), WallClock rechnet Kalenderzeiten (Berlin), Maths liefert die Funktionen der Mathematik-Bibliothek für jedes Profil.

Quelle: userland/maths/ · ohne Datei, in jedem Profil · 25 Deklarationen

SwiftMathsFunktionen der Mathematik-Bibliothek

AufrufWas er tutShape-Aufruf · Zeitbudget
Maths
Maths.sin, .cos, .tan, .asin, .acos, .atan, .atan2, .sinCosTrigonometrie.
Beispiel
let out = p.x * Maths.cos(yaw) + p.y * Maths.sin(yaw)
aus apps/fpcheck (gekürzt)
Maths.sqrt, .hypot, .pow, .exp, .log, .log2, .log10Wurzeln, Potenzen, Logarithmen.
Maths.floor, .ceil, .round, .trunc, .fmod, .radians, .degreesRunden und Umrechnen.
Maths.pi, .eKonstanten.
Alle 25 Deklarationen der Bibliothek (docs/api/libraries.txt)
Maths.static func acos(_ x: Double) -> Double
Maths.static func asin(_ x: Double) -> Double
Maths.static func atan(_ value: Double) -> Double
Maths.static func atan2(_ y: Double, _ x: Double) -> Double
Maths.static func ceil(_ x: Double) -> Double
Maths.static func cos(_ x: Double) -> Double
Maths.static func degrees(_ radians: Double) -> Double
Maths.static func exp(_ x: Double) -> Double
Maths.static func floor(_ x: Double) -> Double
Maths.static func fmod(_ x: Double, _ y: Double) -> Double
Maths.static func hypot(_ x: Double, _ y: Double) -> Double
Maths.static func log(_ x: Double) -> Double
Maths.static func log10(_ x: Double) -> Double
Maths.static func log2(_ x: Double) -> Double
Maths.static func pow(_ x: Double, _ y: Double) -> Double
Maths.static func radians(_ degrees: Double) -> Double
Maths.static func round(_ x: Double) -> Double
Maths.static func sin(_ x: Double) -> Double
Maths.static func sinCos(_ x: Double) -> (sin: Double, cos: Double)
Maths.static func sqrt(_ x: Double) -> Double
Maths.static func tan(_ x: Double) -> Double
Maths.static func trunc(_ x: Double) -> Double
Maths.static let e
Maths.static let pi
enum Maths

video · Video: VP9

Container und Codecs für Aufnahme und Wiedergabe: Matroska/WebM (uses-image), VP9 (uses-video), Opus (uses-opus), WAV und FLAC (mit uses-heap). Camera nimmt MKV mit MJPEG, Ton und Erkennungen auf; Video spielt MKV und WebM (VP9 + Opus).

Quelle: userland/video/ · Datei uses-video · 25 Deklarationen

SwiftVP9Decoder · VP9PictureVideo (VP9)

AufrufWas er tutShape-Aufruf · Zeitbudget
Video (VP9)
VP9Decoder() / .decode(_ packet: [UInt8]) throws(VP9Error) -> VP9Picture?Ein VP9-Paket dekodieren.
Beispiel
guard let shown = try? vp9.decode(bytes) else { return }
let picture = Picture(width: shown.width, height: shown.height, pixels: shown.rgba())
aus apps/video (gekürzt)
VP9Picture.rgba() -> [UInt8] / .y, u, v, yStride, uvStride, width, heightBild als RGBA oder YUV-Ebenen.
Alle 25 Deklarationen der Bibliothek (docs/api/libraries.txt)
VP9Bench.static func computeLoop(_ seed: UInt64) -> UInt64
VP9Decoder.init()
VP9Decoder.mutating func decode(_ packet: [UInt8]) throws(VP9Error) -> VP9Picture?
VP9Decoder.nonisolated(unsafe) static var loopThreads
VP9Decoder.nonisolated(unsafe) static var pause: (() -> Void)?
VP9Decoder.nonisolated(unsafe) static var runParallel: ((@convention(c) (UnsafeMutableRawPointer?, Int, Int) -> Void,
VP9Decoder.var maxPixels
VP9Error.var text: StaticString
VP9Picture.func rgba() -> [UInt8]
VP9Picture.func rgba(into out: inout [UInt8])
VP9Picture.var chromaHeight: Int
VP9Picture.var chromaWidth: Int
VP9Picture.var colorSpace: Int
VP9Picture.var fullRange: Bool
VP9Picture.var height: Int
VP9Picture.var u: [UInt8]
VP9Picture.var uvStride: Int
VP9Picture.var v: [UInt8]
VP9Picture.var width: Int
VP9Picture.var y: [UInt8]
VP9Picture.var yStride: Int
enum VP9Bench
enum VP9Error: UInt8, Error
struct VP9Decoder
struct VP9Picture

qr · QR-Codes

Mit uses-image (braucht uses-heap): Bilder dekodieren und kodieren, PDF schreiben und lesen. Ein Picture hält RGBA-Pixel. PDF lesen ist ungeprüfte Eingabe – die Programme Reader und Image lesen deshalb nur das eine Dokument, das ihnen übergeben wurde. QR-Codes mit uses-qr (ohne Heap).

Quelle: userland/qr/ · Datei uses-qr · 10 Deklarationen

SwiftQRCodeKodieren

AufrufWas er tutShape-Aufruf · Zeitbudget
Kodieren
QRCode.encode(_ bytes: Span<UInt8>, correction: QRCorrection = .medium, mask: Int? = nil) -> QRCode?staticQR-Code im Byte-Modus (Versionen 1 … 10, Stufen L/M/Q/H).
Beispiel
invitationQR = QRCode.encode(bytes.span.extracting(0..<text.count), correction: .medium)
aus apps/server (gekürzt)
QRCode.capacity(version: Int, correction: QRCorrection) -> IntstaticWie viele Bytes passen.
Lesen
QRCode.isDark(x: Int, y: Int) -> Bool / .size / .version / .correction / .maskModule lesen.
Beispiel: QR-Code für eine Einladung (apps/server)
invitationQR = QRCode.encode(bytes.span.extracting(0..<text.count), correction: .medium)
guard let code = invitationQR else { return }
let modules = code.size + 8
for y in 0..<code.size { for x in 0..<code.size where code.isDark(x: x, y: y) { /* Modul füllen */ } }
Alle 10 Deklarationen der Bibliothek (docs/api/libraries.txt)
QRCode.func isDark(x: Int, y: Int) -> Bool
QRCode.let correction: QRCorrection
QRCode.let mask: Int
QRCode.let version: Int
QRCode.static func capacity(version: Int, correction: QRCorrection) -> Int
QRCode.static func encode(_ bytes: Span<UInt8>, correction: QRCorrection = .medium, mask: Int? = nil) -> QRCode?
QRCode.static let maximumVersion
QRCode.var size: Int
enum QRCorrection: Sendable
struct QRCode: Sendable

opus · Opus

Container und Codecs für Aufnahme und Wiedergabe: Matroska/WebM (uses-image), VP9 (uses-video), Opus (uses-opus), WAV und FLAC (mit uses-heap). Camera nimmt MKV mit MJPEG, Ton und Erkennungen auf; Video spielt MKV und WebM (VP9 + Opus).

Quelle: userland/opus/ · Datei uses-opus · 8 Deklarationen

SwiftOpusDecoderTon (Opus)

AufrufWas er tutShape-Aufruf · Zeitbudget
Ton (Opus)
OpusDecoder(head: [UInt8]) / .decode(_ packet: [UInt8]) throws(OpusError) -> [Float] / .reset()Opus-Pakete zu Float-Proben; channels, preSkip, gain.
Alle 8 Deklarationen der Bibliothek (docs/api/libraries.txt)
OpusDecoder.init?(head: [UInt8])
OpusDecoder.mutating func decode(_ packet: [UInt8]) throws(OpusError) -> [Float]
OpusDecoder.mutating func reset()
OpusDecoder.private(set) var channels: Int
OpusDecoder.private(set) var gain: Float
OpusDecoder.private(set) var preSkip: Int
enum OpusError: Error, Equatable
struct OpusDecoder

Zuordnung & Vollständigkeit

Jede Deklaration aus docs/api/app-api-1.txt und jeder Systemaufruf aus shapes/*.shape ist genau einem Modul zugeordnet, als App-API oder System-API (Zahlen „App · System“). Die vollständige Liste je Modul steht am Ende jedes Modulabschnitts („Alle … Deklarationen“).

Zuordnung

ModulSystemaufruf-ModuleRechteSystemaufrufeSwift-Deklarationen
systemcore, system2 · 49 · 397 · 4
programsprograms0 · 25 · 1638 · 53
filesfiles1 · 210 · 544 · 10
databasedatabase0 · 16 · 0134 · 0
networkask, network1 · 112 · 427 · 11
uidisplay, screen1 · 32 · 5354 · 17
soundmicrophone, signal, sound2 · 213 · 538 · 7
cameracamera, vision1 · 110 · 267 · 4
robotarm, devices, robot0 · 26 · 297 · 4
safetysafety0 · 21 · 24 · 2
channelschannels, peers1 · 03 · 026 · 0
clipboardclipboard0 · 03 · 14 · 1
dialogdialog0 · 12 · 212 · 0
updateupdate0 · 10 · 40 · 18
protectionprotection0 · 10 · 50 · 5
Summe24 Module9 · 2382 · 56942 · 136

Vollständigkeit

Rund 1000 Deklarationen sind oben einzeln mit Erklärung genannt, alle übrigen in den Listen je Modul. Bewusst nur zusammengefasst (Felder in einer Zeile) ist, was ein Programm nicht direkt aufruft:

SurfaceMessage-Konstanten (das Draht-Protokoll zwischen Surface und Display-Dienst) · Layout-Offsets von DetectionRing · Einzelfelder von Usage, SystemStatus, UpdateStatus, ZipEntry, ProcessorInfo, FLACInfo, VP9Picture, UIDesign (Palette), Chart-Farben, MatroskaID-Konstanten · Interna von Deflater (Tabellen, Huffman) und HuffmanCode · die Ergebnis-Builder-Technik der Views (ViewBuilder, ViewList, ListAnd, ListOf1) · Hilfsprotokolle ByteSource, ByteSink, ZipDestination, ZipInput · Presentation.presentationIcon/-Bytes.

Nicht in app-api-1.txt: SecureConnection (uses-tls, nicht öffentlich deklariert) und der je Programm erzeugte Tabellen-Code (openDatabase, <Table>). Die Liste enthält heute noch 136 Deklarationen, die hier zur System-API gehören (z. B. Screen, Programs.launch, System.installUpdate); die App-API ohne sie hat 942.