SPB Git

Repository Public License

app-architecture.md 27.8 KB

# ORIX Convert — application architecture

The macOS application shell: project.yml (XcodeGen), App/, Scripts/build.sh, Scripts/shot.sh, Scripts/screenshots.sh, Scripts/localize.py. Conversion code lives in Packages/ (see core-api.md and ENGINE-CONTRACT.md); the app only talks to engines through the generic contract.

# Project

  • Scripts/build.sh generate|debug|release|run|selftest|core-test|strings. The .xcodeproj is generated and gitignored. release signs with Developer ID Application (--timestamp, CODE_SIGN_INJECT_BASE_ENTITLEMENTS=NO); ORIX_RELEASE_ADHOC=1 Scripts/build.sh release builds the Release configuration signed ad hoc.
  • macOS 15.0, arm64, Swift 6, strict concurrency, SWIFT_DEFAULT_ACTOR_ISOLATION: MainActor for the app target (types that must be callable off the main actor are marked nonisolated). Not sandboxed, Hardened Runtime, no entitlement.
  • Document types: any file or folder, role Viewer, rank Alternate — the app accepts drops on the Dock icon and "Open With" without ever becoming a default handler.
  • Post-build phase "Embed tools, helpers and licences" (project.yml):
    1. Licences → Contents/Resources/Licenses: every EmbeddedEngines/*/NOTICE.md as <component>.md, plus the full licence texts ffmpeg/* (from EmbeddedEngines/ffmpeg/licenses), pandoc/COPYING-GPL-2.0.txt and hdf5/LICENSE.txt. LibreOffice keeps its own LICENSE / NOTICE inside its bundle. Settings › About lists the notices; its "Licence…" sheet has a document picker for the texts (LibreOffice's are read from its bundle).
    2. Tools → Contents/Helpers: Release rsyncs EmbeddedEngines/tools/ (symlinks preserved), or the folder given by ORIX_TOOLS_SOURCE (build/signed-tools after Scripts/sign-tools.sh). Debug skips the 700 MB copy (ORIX_EMBED_TOOLS_IN_DEBUG=YES forces it) and the app points the core at EmbeddedEngines/tools through ORIX_CONVERT_TOOLS (EngineCatalog.prepareToolLookup, #if DEBUG only).
    3. Own helpers, built by swift build -c release --build-system native with a clean environment, each in build/helpers/<name> (log build/helpers/<name>.log), copied to Contents/Helpers and signed with the build's identity, Hardened Runtime, and a secure timestamp when the app has one: orix-model3d-helper (EngineModel3D), orix-hdf5-probe (EngineScientific), orix-midi-render (EngineMedia) — required, in Debug too — and, in Release (or ORIX_EMBED_CLI=YES), orix-convert through Scripts/cli-build.sh (optional: a failed build is a warning; @loader_path/../Frameworks is added to its run paths for libduckdb.dylib).
  • libduckdb.dylib (binary target of EngineData) is embedded and signed in Contents/Frameworks by Xcode.
  • Scripts/build.sh release passes ARCHS=arm64 on the command line: with ONLY_ACTIVE_ARCH=NO Xcode would also compile the packages for x86_64, where Float16 (scientific engine) does not exist.
  • ORIX_APP=<app> Scripts/build.sh selftest runs the self-test of any built app with env -i HOME TMPDIR PATH=/usr/bin:/bin.

# Structure

text
App/Sources/App            entry point, AppDelegate, AppModel, AppSection, EngineCatalog, launch options,
                           self-test, self-screenshot, string lookup (L / LE), engine string harvest
App/Sources/DesignSystem   Tokens (colour roles, gradient, spacing, radii, category colours), Components,
                           FormatBadge, ProgressViews
App/Sources/Features/SmartDrop   WorkspaceModel + Prepare pane (groups, destination picker, generated options,
                                 presets, warnings, output bar)
App/Sources/Features/Queue       QueueModel + Queue pane (rows, decisions, summary, inspector, log sheet)
App/Sources/Features/History     HistoryModel + list and detail
App/Sources/Features/Metadata    MetadataModel + Metadata Studio, shared InspectionContent
App/Sources/Features/Formats     registry browser and matrix export
App/Sources/Features/Settings    Settings scene (General, Performance, Privacy, Advanced, About)
App/Sources/Features/Shared      Finder actions, Quick Look, Dock progress, notification, sample files, KeyLabels
App/Sources/Features/Studio      what the studios share: CompareCanvas (zoomable canvas), TargetCatalog / TargetPicker,
                                 StudioRunner (private queue), PictureSource, PixelMath
App/Sources/Features/QualityLab  QualityLabModel + view, WaveformView
App/Sources/Features/VectorStudio  VectorStudioModel + view
App/Sources/Features/Flow        FlowDocument (editable workflow, conditions, built-ins, messages), FlowModel, FlowView
                                 (library + canvas), FlowPanel (step editor, run, history)
App/Sources/Features/WatchFolders  WatchModel, WatchView (rules, activity, rule sheet), MenuBarController

AppModel (@Observable, main actor) owns the core services (ConversionJobManager, PresetStore, settings) and one model per feature. Views are thin and read the models through the environment.

  • Every file entry point ends in AppModel.ingest(urls:): window drop, Add Files / Add Folder, paste, Dock icon, open, -ORIXOpen. The Services / Finder Quick Action must call the same function (markers EXTENSION POINT in App/Sources/App/AppDelegate.swift and project.yml).
  • WorkspaceModel runs SmartDropAnalyzer, groups files by detected format, and for each group keeps the chosen destination (TargetChoice: a real ConversionPlan), the option values, and the warnings gathered by SmartDropAnalyzer.preflight for every file (recomputed when the destination or an option changes). Only destinations returned by the capability resolver or reachable by a real two-step plan are ever listed.
  • QueueModel mirrors ConversionQueue.events() into one @Observable JobItem per job (a progress tick redraws one row). Progress is determinate only when the engine measured a fraction; the batch progress is "settled jobs + measured fractions over the number of jobs"; ETA and throughput appear only when they can be derived from measured values. A running job has no Pause control (the core cannot suspend an engine), only Cancel.
  • Secrets: option keys containing password are rendered as SecureFields, live only in the staged group and in the in-memory job request, are stripped from presets, from the history (core: ConversionOptions.redactingSecrets) and from every "copy details" / inspector view.
  • Estimated output size: not shown. No engine exposes a real basis for one, so the app does not invent it.
  • Combining across format groups: when several staged groups have chosen the same multi-source path (same engine, destination and operation — WorkspaceModel.combineKey), each offers "One file with the … too"; the groups then become one job whose sources are their files in group order, with the options of the first group. Nothing is offered between groups whose formats do not share that path.
  • Prepare rows are keyboard-selectable (WorkspaceModel.selectedFileID): arrows, space = Quick Look, delete removes.
  • KeyLabels gives the generic validation check names and the common fact keys a label from the string catalog (output.not-empty → "Output is not empty", dpi → "Resolution (dpi)"), falling back to the raw key.
  • The welcome chips come from a curated list of everyday pairs, each shown only when the registry has a verified path for it (ExampleChips.curated), with the former automatic pick as a fallback.
  • OptionControl: an integer option whose unit is % is a slider; a choice whose menu does not fit next to its label goes under it.
  • Settings are a JSON file in the support folder (settings.json), next to history.sqlite and presets.json, so -ORIXDataDir isolates all three.

# Adding a section

  1. Add a case to AppSection (App/Sources/App/AppSection.swift) with its group, title, symbol.
  2. Return its view from SectionHost in App/Sources/App/RootView.swift.
  3. The sidebar, the Go menu (⌘1…⌘9) and -ORIXSection <rawValue> pick it up automatically.

A section gets AppModel from the environment; add its own @Observable model to AppModel as a lazy property like the existing ones. Use HeaderBar, Card, Banner, EmptyState, FormatBadge, ORIXProgressBar / ORIXProgressRing and the ORIX.Palette roles. Files dropped on the window go to AppModel.receive(urls:), which hands them to the visible studio (Quality Lab, Vector Studio, Flow) and stages them everywhere else.

# The studios

All four are built. They share App/Sources/Features/Studio:

  • StudioRunner owns a second ConversionQueue (same registry, no history, at most two jobs). Quality Lab trial conversions and Vector Studio exports are ordinary jobs on it — planner, engine, validation, safe writer — that never appear in the Convert queue or the history. Its scratch folder is $TMPDIR/ai.spboucher.orix.convert.studio-<pid>, removed at quit.
  • CompareCanvas (NSViewRepresentable over CanvasNSView, drawn with Core Graphics): one pane, two synchronized panes or a draggable split; each side is a CanvasLayer — a bitmap (preview + optional "detail" bitmap), filled CGPath layers or stroked outlines with nodes. Zoom is expressed in device pixels per image pixel (Viewport, shared with the toolbar and the View menu: ⌘+ ⌘− ⌘0 ⇧⌘1); bitmaps switch to nearest-neighbour as soon as one bitmap pixel covers more than one device pixel; scroll pans, ⌘-scroll / pinch / mouse wheel zoom around the pointer, double-click toggles fit and 100 %, arrow keys pan, [ ] move the split.
  • TargetCatalog / TargetPicker / TargetButton: destinations that are real for a format (or every destination of the registry, for workflow steps and watch rules), not tied to the Convert workspace.

Quality Lab (QualityLabModel). open(url, target:) inspects the file, lists its real single-file destinations and starts the trial; setOption re-runs it 450 ms after the last change, cancelling the stale job. The previous comparison stays on screen while a new run converts. After a run: both files are inspected, pictures are decoded through PictureSource (ImagePreview, PDFPreview.thumbnail, SVGWebRenderer.bitmap, MediaQualityLab.videoFrame), PSNR / largest difference / differing pixels come from ImageComparison.compare on the two previews (only when they have the same pixel size; the panel says at which size), the difference view is PixelMath.difference (absolute difference × 1 / 4 / 16 / 64). Bounded decodes: previews are at most 2048 px on the long side; a "detail" bitmap of at most 8192 px (PictureSource.detailLimit) is decoded only for images whose file holds more than the preview, and is what the canvas draws past the preview's resolution and what the pixel inspector reads (it says so when the file is larger than the cap). Audio → audio shows WaveformCompare (MediaQualityLab.waveform, 4000 buckets). A result made of several files (pages) is compared page by page; a result folder is expanded to its files. When one side cannot be drawn the stage says so and the Facts tab remains. "Use These Settings" stages the file in Convert with the same destination and options; the bookmark button saves a preset (secrets removed).

Vector Studio (VectorStudioModel). The image is decoded with the engine's RasterDecoder; the controls are the engine's own descriptors for its image.vectorize path (the mode is drawn as chips and VectorEngine.presetOptions(for:) fills the form). Every change cancels the running trace (CancelFlag, polled by Vectorizer), runs .preview(maxDimension: 512) after 45 ms, then the full pass after 380 ms of rest. The canvas draws VectorDocument.cgLayers. Export SVG / vector PDF runs the engine's path on the StudioRunner queue into the file chosen in a save panel; "Copy SVG" puts the full-pass SVG on the pasteboard; the drag handle provides an .svg file representation written when it is dropped; "Apply to Files…" enqueues image.vectorize jobs with the current options in the Convert queue. The palette strip is display-only: the engine has no per-colour exclusion.

Flow (FlowModel, FlowDocument). The document is the core Workflow with stable node identifiers. Every edit goes through FlowModel.edit(_:_:), which registers the previous document in the model's own UndoManager (Edit › Undo / Redo call it while Flow is visible), re-validates with WorkflowValidator and saves to the WorkflowLibrary 250 ms later. Issues are attached to cards by the validator's nodePath; FlowMessages rewrites the validator's sentences in the user's language. Built-in examples (BuiltInWorkflows) are plain Workflow values validated at launch against the formats they are meant for (strict inputFormats); the ones that fail are not offered; they are read-only and can be duplicated. runNow() hands the in-memory workflow to manager.workflowRunner: its conversions are jobs of the main queue (they appear in Convert › Queue); per-item progress is read from the jobs carrying the run's counter. A workflow handles files one by one and a branch runs one of its two lanes: neither "several inputs → one output" nor "two outputs from one input in parallel" exist in the core model. Secrets typed in a convert step stay in the in-memory document (they are used by runs started from it) and are removed by WorkflowLibrary whenever it stores or exports.

Watch Folders (WatchModel). A thin layer over the core's FolderWatcher, started at launch. Folders enter a rule only through NSOpenPanel (FolderPanel.choose), where the bookmark is taken. The sheet runs FolderWatcher.loopRisk on the draft before saving, and addRule checks again. Rule status is derived (watching / paused / all paused / folder missing or destination read-only). Rules never store secrets. The optional menu bar item (MenuBarController, setting keepInMenuBar, off by default) keeps the app alive when its window is closed (applicationShouldTerminateAfterLastWindowClosed); nothing is registered at login.

# Adding an engine

  1. Check that the package builds: swift build in Packages/Engine<Name> and that it exposes makeEngines().
  2. project.yml: add the package under packages: and - package: Engine<Name> under the target's dependencies.
  3. App/Sources/App/EngineCatalog.swift: one import Engine<Name>, one line Engine<Name>.makeEngines, in factories, and the name in wiredPackages. If the engine runs a large helper process, add its engine identifier to heavyEngineIDs.
  4. Scripts/build.sh debug && Scripts/build.sh selftest, then Scripts/build.sh strings to harvest its strings.

All thirteen engine packages are wired (15 engines). Static xcframeworks must carry their module map in Headers/<Module>/module.modulemap (EmbeddedEngines/normalize-xcframework.sh): Xcode copies the headers of every xcframework into one include directory. Model3DEngine is created with isolation: .required (Release always; Debug when the helper is there). The archive engine is registered with makeEngines() = archive-specific paths only.

# Generic operations (any files → archive)

"Create ZIP / 7z / TAR… archive" and "Compress to gzip / bzip2 / xz / zstd" are declared once by the archive engine from the .folder pseudo-source. SmartDropAnalysis.selectionOperations / .fileOperations carry them and WorkspaceModel appends them to the operations of every group, including unrecognised files (StagedGroup.genericIDs); they are never a default choice. A choice made from them has TargetChoice.isGeneric: the plan starts at .folder and the request carries sourceFormat: .folder. Groups (and the folder group) that pick the same generic multi-source operation share one combineKey and are combined into ONE job by default ("One file with the … too" separates them). Caveat: a dropped folder is both a folder entry and its expanded files; choosing the archive for both puts the files in twice.

# Previews

Features/Preview: FilePreviewModel (lazy, cancellable, loads off the main actor, bounds in FilePreviewModel.Bounds) and FilePreviewView. Shown in Metadata Studio (card "Preview") and in the Convert side panel ("Preview" disclosure, closed by default; -ORIXPanel preview opens it). Sources: ImagePreview.decode, PDFPreview.thumbnail (first 3 pages), Model3DPreviewLoader (helper process; SCNView with camera control and a wireframe toggle; models above 512 MB are not loaded), DataPreview.preview (first 100 rows, detected types, sheet picker), ArchiveBrowser.list (200 entries per page, filter, encrypted / unsafe-name marks, nothing extracted), LoadedFont.preview + glyphs(in:) (four sizes, pages of 96 glyphs, the font's embedding statement), SubtitleParser.parse (first 400 cues), GeoPreview.preview (Core Graphics plot of the first 400 features in the file's coordinates + attribute table; no tiles, no network), MediaQualityLab.waveform / .videoFrame, and QLThumbnailGenerator for documents, ebooks, presentations and SVG. Formats without any of these (scientific containers, unrecognised files) say that no preview exists. Self-screenshots replace the live SCNView by one SCNView.snapshot() of the same scene (cacheDisplay does not capture a Metal layer).

# System integrations

  • Services: Info.plist NSServices — "Convert with ORIX Convert", NSSendFileTypes: [public.item], message convertFiles. ServicesProvider (registered as NSApp.servicesProvider) reads the pasteboard's file URLs and calls AppModel.ingest(urls:). macOS lists a new service after the app has been in /Applications and pbs has rescanned; it may have to be ticked in System Settings › Keyboard › Keyboard Shortcuts › Services.
  • Finder Quick Action / Share extension: not built. An Action extension is a separate sandboxed target with its own signing and an App Group or XPC hand-off to the (unsandboxed) app, and its appearance in Finder cannot be verified without driving the screen. The Services entry covers the same gesture (Finder › right click › Services).
  • App Intents (Features/Integration/AppIntents.swift): ConvertFilesIntent (files, format entity listing the registry's plain destinations, optional preset), DetectFormatIntent, RunWorkflowIntent (entity query over saved and built-in workflows), ORIXConvertShortcuts. openAppWhenRun = false; they run on the app's own queue and write results under $TMPDIR/ai.spboucher.orix.convert.intents (swept after a day). Intent titles are English only.
  • Command line: Settings › Advanced › "Install command-line tool…" shows the sudo ln -sf command for Contents/Helpers/orix-convert; the app writes nothing outside itself.
  • Presets: BuiltInPresets.all (27), validated at launch by BuiltInPresets.validated(in:) — path, option keys, ranges and choices — and registered through PresetStore.registerBuiltIns; rejected ones are logged (Logger category presets) and not offered.

# Launch arguments (Debug and Release)

Only honoured when given. -AppleLanguages / -AppleLocale pass through (this Mac is French: use -AppleLanguages "(en)" -AppleLocale en_US for English).

Argument Effect
-ORIXSection <id> Section at launch: convert, qualityLab, vectorStudio, flow, watchFolders, history, metadata, formats; settings or settings:<general|performance|privacy|advanced|about> opens the Settings window
-ORIXOpen <path> Repeatable. Files or folders ingested at launch (inspected when the section is metadata; opened by the studio when the section is qualityLab, vectorStudio or flow)
-ORIXTarget <format> or <format>#<operation> Destination chosen for every group that can reach it (e.g. png, pdf#pdf.merge); in Quality Lab, the destination of the trial
-ORIXOption key=value Repeatable. Quality Lab: option values of the trial (quality=12)
-ORIXView <mode> Quality Lab: sidebyside, split, original, result, difference. Vector Studio: original, vector, split, outline, nodes
-ORIXZoom <percent>, -ORIXCenter x,y Zoom of the studio canvas (100 = one image pixel per screen pixel) and the image point (0…1) at its centre
-ORIXVectorMode <mode> Vector Studio: logo, line-art, monochrome, illustration, icon, technical, high-detail
-ORIXWorkflow <id | key | name> Flow: workflow opened (built-in keys: images-webp, pdf-ocr, media-branch, scans-pdf, large-photos)
-ORIXFlowRun YES Flow: run the opened workflow over the -ORIXOpen files; paths without an export step write to -ORIXOutputDir
-ORIXSeedDemo YES With -ORIXDataDir: Flow gets two demonstration workflows (one valid, one with an impossible step); Watch Folders gets three rules on folders created under the data directory, real files are dropped and really converted
-ORIXAutoStart YES Start converting once the launch files are analysed
-ORIXOutputDir <dir> Results of the launch batch go to this folder
-ORIXConflict ask|keep|skip Conflict policy of the launch batch
-ORIXAppearance light|dark Forces the appearance
-ORIXWindowSize WxH Content size of the main window
-ORIXDataDir <dir> Isolated settings, presets and history (sets ORIX_CONVERT_SUPPORT_DIR for the process)
-ORIXPane prepare|queue Pane of the Convert section
-ORIXSelect first|<format> Selects the first job / history entry, a staged group, or a format in Formats; in Flow, the step with that path (2, 2.then.1)
-ORIXPanel log|options|inspector Opens the log sheet of the first job / the side panel in narrow windows; facts (Quality Lab), run / history (Flow), rule (Watch Folders: the rule sheet)
-ORIXShot <png> + -ORIXShotDelay <s> Draws the window (attached sheet or Settings window when relevant) into a PNG with cacheDisplay, then exit(0)
-ORIXSelfTest YES Runs the end-to-end scenario, prints SELFTEST lines, exits 0 or 1
-ORIXMakeSamples <dir> + -ORIXSampleCount <n> Writes generated sample files (plus n bulk files), then exits
-ORIXMakePreviewSamples <dir> Writes one generated file per kind of preview (torus OBJ, CSV, GeoJSON, SRT, a system font copy, a ZIP of them made by the archive engine), then exits
-ORIXMakeStudioSamples <dir> Writes the studios' samples: a logo, a photo, a 50-megapixel photo (Core Graphics), a 6 s video and a 12 s audio file (bundled ffmpeg, through BundledTools), then exits
-ORIXDumpEngineStrings <json> Writes the strings declared by the wired engines, then exits

Unattended modes (-ORIXShot, -ORIXSelfTest, -ORIXMakeSamples, -ORIXMakeStudioSamples, -ORIXDumpEngineStrings) switch the app to the accessory activation policy and make its windows fully transparent and click-through: nothing appears on screen, no focus is taken, no alert or notification is shown. -ORIXSelfTest without -ORIXDataDir uses a temporary data folder: the user's data is never touched.

# Screenshots

Scripts/shot.sh <out.png> <section> [light|dark] [extra arguments…] wraps the arguments above (ORIX_LANG=fr, ORIX_SIZE, ORIX_DELAY, ORIX_DATA, ORIX_SAMPLES). Scripts/screenshots.sh [folder] captures every built section in both appearances on generated samples, running real conversions for the queue and history shots, and every studio state (20-… Quality Lab, 30-… Vector Studio, 40-… Flow, 50-… Watch Folders) on real trial conversions, traces, workflow runs and watched folders. ORIX_ONLY=studios captures only those; ORIX_LOOKS=dark one appearance. ORIX_ONLY=previews captures 60-… to 73-…: the preview surfaces, the archive workspace and the settings rows. Because the window is never key, native controls (switches, list selection, window buttons) are drawn in their inactive state; everything drawn by the design system is unaffected.

# Self-test

Scripts/build.sh selftest (or -ORIXSelfTest YES) runs App/Sources/App/SelfTest.swift inside the app, through the same model code the UI calls, on files generated in a temporary folder: content analysis and grouping, wrong extension, unrecognisable file, PDF → PNG with a password option (history rows written, the secret absent from every stored file), merge with reordering, "keep both", images → one PDF, "ask" then skip, cancel (waiting and running), source deleted before start, read-only destination, quit with jobs running, history search, Metadata Studio inspection and discovered actions, a 500-file mixed drop, and the studios: JPEG + PNG combined into one PDF across format groups; a Quality Lab trial PNG → JPEG (both bitmaps decoded, size ratio and PSNR measured, nothing written next to the source, one trial folder kept after a re-run); a logo traced in Vector Studio and exported as SVG (path elements, no <image>) and vector PDF; a built-in workflow run over three files with its outputs and history row; a workflow with an impossible step refused; undo / redo; a password typed in a workflow absent from every stored file; and a watch rule that picks up a dropped PNG, converts it, does not re-process its own output and stops picking up when paused (this part waits on the watcher's two-second settle time: about 15 s). SelfTestIntegration.swift then runs one real conversion per wired engine (CSV ↔ Parquet, CSV ↔ XLSX, OBJ → GLB through the helper, WAV → MP3, video → MP4, Markdown → PDF, DOCX → PDF, SRT → VTT, TTF → WOFF2, GeoJSON → KML, PNG → WebP / HEIC / SVG), the generic archive capability through the workspace, archive passwords, the cross-component fixes, the presets, every kind of preview, the Services provider, application(_:open:), the three App Intents, and prints where each helper tool and libduckdb were really loaded from (in Release every path must be inside the app bundle). Output: one SELFTEST PASS|FAIL <name> line per check and SELFTEST RESULT: PASS|FAIL (n passed, m failed); the exit status is 1 when a check fails.

# Localization (en + fr-CA)

  • App strings: L("English text") / L("… %@ … %lld", args). Scripts/localize.py (run by build.sh generate) extracts every key from App/Sources and writes App/Resources/Localizable.xcstrings with the French from Scripts/translations-fr.json. Scripts/localize.py --check fails when a key has no French.
  • Engine strings (option labels, help, groups, choices, placeholders, units, operation titles, limitations, format names, warnings, errors, validation details, inspection fields) stay English in the engines and go through LE("English text"): exact lookup in Engines.xcstrings, then the patterns of EnginePatterns.json for interpolated messages (%@ per interpolation; captures are looked up too; %1$@ reorders), then the English text.
  • Scripts/build.sh strings (= localize.py --harvest) refreshes Scripts/engine-strings.json: the built app dumps what its engines declare, and the sources of the wired packages are scanned for warning / error / validation / inspection / progress messages. French goes in Scripts/translations-engines-fr.json; Scripts/localize.py --missing lists what is not translated yet.
  • Sizes, dates, numbers and durations use the formatted() APIs (Fmt in L10n.swift).

# Accessibility

Custom views carry labels, values and hints (format badges, progress, drop zone, job rows, decisions, summary; the comparison canvas — adjustable: it moves the split —, the waveforms, the pixel inspector, the workflow cards with their issues and named actions, rule cards and activity rows). The Prepare list, the Flow canvas and both canvases take the keyboard (arrows, space, delete, ⌘D in Flow). Colour is never the only signal: states, severities and fidelity pair a symbol and a word with their colour. ORIX.Palette colours follow light / dark and switch to stronger values when Increase Contrast is on. Animations (progress fill, drop highlight, indeterminate indicators) stop or become static with Reduce Motion.

Files main
Menu

Theme