enigma-memory 0.1.17 → 0.1.22

package/apps/ios/EnigmaIOS/Enigma/OnboardingView.swift

@@ -0,0 +1,105 @@
+import SwiftUI
+
+struct OnboardingView: View {
+    @EnvironmentObject private var model: AppModel
+    @State private var server = ""
+    @State private var issuer = ""
+    @State private var clientID = ""
+    @State private var resource = ""
+    @State private var directToken = ""
+    @State private var showAdvanced = false
+
+    var body: some View {
+        ScrollView {
+            VStack(alignment: .leading, spacing: 26) {
+                Spacer(minLength: 24)
+                HStack(spacing: 10) {
+                    EnigmaMark(size: 26)
+                    Text("Enigma.").font(.system(.title2, design: .serif, weight: .bold))
+                }
+                VStack(alignment: .leading, spacing: 11) {
+                    SectionEyebrow(text: "PRIVATE AI WORKSPACE")
+                    Text("Your intelligence.\nYour boundary.")
+                        .font(.system(size: 42, weight: .medium, design: .serif))
+                        .tracking(-1.4)
+                    Text("Connect to an Enigma server with OAuth PKCE. Conversation memory remains in this app process unless you explicitly save it.")
+                        .font(EnigmaTheme.body)
+                        .foregroundStyle(EnigmaTheme.secondary)
+                        .fixedSize(horizontal: false, vertical: true)
+                }
+                VStack(alignment: .leading, spacing: 14) {
+                    field("Enigma server", text: $server, prompt: "https://api.example.com")
+                    field("OAuth issuer", text: $issuer, prompt: "https://auth.example.com")
+                    field("OAuth client ID (optional)", text: $clientID, prompt: "auto-register when permitted")
+                    field("Protected resource", text: $resource, prompt: "https://api.example.com")
+                    Text("Leave client ID blank to request an approved public-client registration for this app.")
+                        .font(.caption)
+                        .foregroundStyle(EnigmaTheme.muted)
+                    Button("Connect with OAuth PKCE") {
+                        model.configure(server: server, issuer: issuer, clientID: clientID, resource: resource)
+                        Task { await model.connectWithOAuth() }
+                    }
+                    .buttonStyle(PrimaryButtonStyle())
+                    .disabled(model.isBusy || server.isEmpty || issuer.isEmpty || resource.isEmpty)
+                }
+                .enigmaSurface(padding: 18)
+
+                DisclosureGroup("Local development token", isExpanded: $showAdvanced) {
+                    VStack(alignment: .leading, spacing: 12) {
+                        Text("For a loopback development server only. The token is stored in Keychain and never written to UserDefaults.")
+                            .font(.footnote)
+                            .foregroundStyle(EnigmaTheme.secondary)
+                        SecureField("Direct bearer token", text: $directToken)
+                            .textInputAutocapitalization(.never)
+                            .autocorrectionDisabled()
+                            .padding(12)
+                            .background(.white)
+                            .overlay(RoundedRectangle(cornerRadius: 9).stroke(EnigmaTheme.line))
+                        Button("Use direct token") {
+                            model.configure(server: server, issuer: issuer, clientID: clientID, resource: resource)
+                            Task { await model.connectWithToken(directToken) }
+                        }
+                        .buttonStyle(.bordered)
+                        .disabled(server.isEmpty || directToken.isEmpty)
+                    }
+                    .padding(.top, 12)
+                }
+                .font(.subheadline.weight(.medium))
+
+                VStack(alignment: .leading, spacing: 6) {
+                    privacyLine("No provider-native memory is treated as canonical.")
+                    privacyLine("Smart Privacy runs on-device before external routes.")
+                    privacyLine("OAuth tokens use Keychain with this-device-only access.")
+                }
+                Spacer(minLength: 24)
+            }
+            .padding(.horizontal, 24)
+        }
+        .onAppear {
+            server = model.serverAddress
+            issuer = model.oauthIssuer
+            clientID = model.oauthClientID
+            resource = model.oauthResource
+        }
+    }
+
+    private func field(_ label: String, text: Binding<String>, prompt: String) -> some View {
+        VStack(alignment: .leading, spacing: 6) {
+            Text(label.uppercased()).font(EnigmaTheme.label).tracking(1).foregroundStyle(EnigmaTheme.muted)
+            TextField(prompt, text: text)
+                .textInputAutocapitalization(.never)
+                .autocorrectionDisabled()
+                .keyboardType(.URL)
+                .padding(12)
+                .background(.white)
+                .overlay(RoundedRectangle(cornerRadius: 9).stroke(EnigmaTheme.line))
+        }
+    }
+
+    private func privacyLine(_ value: String) -> some View {
+        HStack(alignment: .top, spacing: 8) {
+            Text("·").foregroundStyle(EnigmaTheme.ember)
+            Text(value).font(.footnote).foregroundStyle(EnigmaTheme.muted)
+        }
+    }
+}

package/apps/ios/EnigmaIOS/Enigma/PrivateVaultView.swift

@@ -0,0 +1,275 @@
+import EnigmaCore
+import SwiftUI
+import WebKit
+
+struct PrivateVaultView: View {
+    @EnvironmentObject private var model: AppModel
+
+    var body: some View {
+        List {
+            Section {
+                HStack(spacing: 12) {
+                    EnigmaMark(size: 30)
+                    VStack(alignment: .leading, spacing: 2) {
+                        Text("Private").font(.system(.title3, design: .serif, weight: .semibold))
+                        Text("Owner-controlled memory and accountless credits").font(.caption).foregroundStyle(EnigmaTheme.muted)
+                    }
+                }
+                .padding(.vertical, 8)
+            }
+            Section("Private economy") {
+                NavigationLink { CreditsView() } label: {
+                    Label {
+                        VStack(alignment: .leading) {
+                            Text("Credits")
+                            Text(model.creditsVault.map { "\($0.balance) private credits" } ?? "Create or recover a vault")
+                                .font(.caption).foregroundStyle(EnigmaTheme.muted)
+                        }
+                    } icon: { Image(systemName: "wallet.pass") }
+                }
+                NavigationLink { UsageView() } label: {
+                    Label("Usage without content", systemImage: "chart.bar.xaxis")
+                }
+            }
+            Section("Disposable tools") {
+                NavigationLink { BrowserToolView() } label: {
+                    Label("Private browser", systemImage: "globe")
+                }
+            }
+            Section("Boundary") {
+                NavigationLink { PrivacyDetailView() } label: {
+                    Label("Smart Privacy receipt", systemImage: "checkmark.shield")
+                }
+                NavigationLink { SettingsView() } label: {
+                    Label("Connection settings", systemImage: "slider.horizontal.3")
+                }
+            }
+        }
+        .scrollContentBackground(.hidden)
+        .background(EnigmaTheme.canvas)
+        .navigationTitle("Private")
+        .task { await model.refreshCredits(); await model.refreshUsage() }
+    }
+}
+
+struct CreditsView: View {
+    @EnvironmentObject private var model: AppModel
+    @State private var recovery = ""
+
+    var body: some View {
+        ScrollView {
+            VStack(alignment: .leading, spacing: 18) {
+                VStack(alignment: .leading, spacing: 8) {
+                    SectionEyebrow(text: "PRIVATE CREDITS")
+                    Text("Accountless balance.\nRotating recovery.").font(EnigmaTheme.display)
+                    Text("The credits ledger stores no email, wallet, or customer identity. Save each new recovery code offline.")
+                        .font(.subheadline).foregroundStyle(EnigmaTheme.secondary)
+                }
+                HStack(spacing: 0) {
+                    metric("BALANCE", value: model.creditsVault.map { "\($0.balance)" } ?? "0")
+                    Divider().overlay(EnigmaTheme.line)
+                    metric("AVAILABLE", value: model.creditsVault.map { "\($0.available)" } ?? "0")
+                }
+                .enigmaSurface(padding: 0)
+                if let code = model.recoveryCodeShownOnce {
+                    VStack(alignment: .leading, spacing: 10) {
+                        SectionEyebrow(text: "RECOVERY CODE — SHOWN ONCE")
+                        Text("Store this offline. Successful recovery rotated the old code and revoked every prior credits access token.")
+                            .font(.footnote).foregroundStyle(EnigmaTheme.secondary)
+                        Text(code).font(.system(.caption, design: .monospaced)).textSelection(.enabled)
+                            .padding(10).background(.white).overlay(RoundedRectangle(cornerRadius: 8).stroke(EnigmaTheme.line))
+                        HStack {
+                            Button("Copy") { UIPasteboard.general.string = code }
+                            Spacer()
+                            Button("Dismiss permanently", role: .destructive) { model.dismissRecoveryCode() }
+                        }
+                        .font(.footnote.weight(.semibold))
+                    }
+                    .enigmaSurface()
+                }
+                if model.creditsVault == nil {
+                    Button("Create private vault") { Task { await model.createCreditsVault() } }
+                        .buttonStyle(PrimaryButtonStyle())
+                }
+                VStack(alignment: .leading, spacing: 9) {
+                    Text("RECOVER AND ROTATE").font(EnigmaTheme.label).foregroundStyle(EnigmaTheme.muted)
+                    SecureField("enigma_cr_…", text: $recovery)
+                        .textInputAutocapitalization(.never).autocorrectionDisabled()
+                        .padding(12).background(.white).overlay(RoundedRectangle(cornerRadius: 9).stroke(EnigmaTheme.line))
+                    Button("Recover vault") { Task { await model.recoverCreditsVault(recovery); recovery = "" } }
+                        .buttonStyle(.bordered)
+                        .disabled(recovery.isEmpty)
+                }
+                .enigmaSurface()
+
+                VStack(alignment: .leading, spacing: 8) {
+                    SectionEyebrow(text: "FUNDING LINKABILITY")
+                    Text(model.creditsVault?.paymentFundingBoundary ?? "Funding can be linkable: on-chain rails can reveal a wallet and Stripe can identify a customer. A separate payment ledger maps the funding event to the pseudonymous vault.")
+                        .font(.footnote).foregroundStyle(EnigmaTheme.secondary)
+                    if !model.creditPackages.isEmpty {
+                        Text(model.creditPackages.map { "\($0.label): \($0.rails.joined(separator: ", "))" }.joined(separator: "\n"))
+                            .font(.caption).foregroundStyle(EnigmaTheme.muted)
+                    }
+                }
+                .enigmaSurface()
+                if model.creditsVault != nil {
+                    Button("Forget this device session", role: .destructive) { model.forgetCreditsSession() }
+                        .font(.footnote.weight(.semibold))
+                }
+            }
+            .padding(20)
+        }
+        .navigationTitle("Credits")
+        .navigationBarTitleDisplayMode(.inline)
+        .enigmaCanvas()
+    }
+
+    private func metric(_ label: String, value: String) -> some View {
+        VStack(alignment: .leading, spacing: 5) {
+            Text(label).font(EnigmaTheme.label).foregroundStyle(EnigmaTheme.muted)
+            Text(value).font(.system(.title, design: .serif, weight: .medium))
+            Text("private credits").font(.caption2).foregroundStyle(EnigmaTheme.muted)
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .padding(16)
+    }
+}
+
+struct UsageView: View {
+    @EnvironmentObject private var model: AppModel
+
+    var body: some View {
+        ScrollView {
+            VStack(alignment: .leading, spacing: 18) {
+                SectionEyebrow(text: "30 DAY USAGE")
+                Text("Counts, never content.").font(EnigmaTheme.display)
+                if let usage = model.usage {
+                    LazyVGrid(columns: [.init(.flexible()), .init(.flexible())], spacing: 10) {
+                        usageMetric("EVENTS", "\(usage.totals.eventCount)")
+                        usageMetric("INPUT", "\(usage.totals.inputUnits)")
+                        usageMetric("OUTPUT", "\(usage.totals.outputUnits)")
+                        usageMetric("KNOWN COST", (Double(usage.totals.knownCostMicrousd) / 1_000_000).formatted(.currency(code: "USD")))
+                    }
+                    Text(usage.costBoundary).font(.footnote).foregroundStyle(EnigmaTheme.secondary)
+                    Label(usage.contentStored ? "Content stored" : "No prompts, outputs, or credentials stored", systemImage: usage.contentStored ? "exclamationmark.triangle" : "checkmark.shield")
+                        .font(.footnote.weight(.semibold)).foregroundStyle(usage.contentStored ? .red : EnigmaTheme.success)
+                } else { ContentUnavailableView("No usage", systemImage: "chart.bar", description: Text("No metered events in this period.")) }
+            }
+            .padding(20)
+        }
+        .refreshable { await model.refreshUsage() }
+        .navigationTitle("Usage")
+        .navigationBarTitleDisplayMode(.inline)
+        .enigmaCanvas()
+    }
+
+    private func usageMetric(_ label: String, _ value: String) -> some View {
+        VStack(alignment: .leading, spacing: 5) {
+            Text(label).font(EnigmaTheme.label).foregroundStyle(EnigmaTheme.muted)
+            Text(value).font(.system(.title2, design: .serif, weight: .medium))
+        }.frame(maxWidth: .infinity, minHeight: 82, alignment: .leading).enigmaSurface()
+    }
+}
+
+struct PrivacyDetailView: View {
+    @EnvironmentObject private var model: AppModel
+
+    var body: some View {
+        List {
+            if let receipt = model.lastPrivacyReceipt {
+                Section("Last turn") {
+                    LabeledContent("Mode", value: receipt.mode.rawValue.capitalized)
+                    LabeledContent("Reference", value: String(receipt.receiptReference.uuidString.prefix(12)) + "…")
+                    LabeledContent("Input shape", value: "\(receipt.inputCharacters) characters")
+                }
+                Section("Categories") {
+                    ForEach(receipt.summary, id: \.self) { finding in
+                        LabeledContent(finding.category.rawValue, value: "\(finding.action) × \(finding.count)")
+                    }
+                }
+            } else { ContentUnavailableView("No receipt", systemImage: "checkmark.shield", description: Text("Send a protected chat turn first.")) }
+            Section { Text("Operational receipts contain category counts and a random reference—not prompt text, completion text, or a deterministic prompt hash.") }
+        }
+        .navigationTitle("Smart Privacy")
+    }
+}
+
+struct BrowserToolView: View {
+    @EnvironmentObject private var model: AppModel
+    @State private var address = "https://example.com"
+
+    var body: some View {
+        VStack(spacing: 12) {
+            HStack {
+                TextField("https://example.com", text: $address)
+                    .textInputAutocapitalization(.never).autocorrectionDisabled().keyboardType(.URL)
+                    .textFieldStyle(.roundedBorder)
+                Button("Go") { Task { await model.navigatePrivateBrowser(address) } }
+                    .disabled(model.browserSession == nil)
+            }
+            .padding(.horizontal)
+            if let session = model.browserSession, let raw = session.streamUrl,
+               let stream = URL(string: raw), let expected = URL(string: model.browserViewerOrigin), sameOrigin(stream, expected) {
+                EphemeralBrowserView(url: stream, allowedOrigin: expected)
+            } else {
+                ContentUnavailableView(
+                    "No private browser",
+                    systemImage: "globe",
+                    description: Text(model.browserViewerOrigin.isEmpty ? "Set the signed viewer origin in Connection settings first." : "Start a broker session after network-level egress proof is available.")
+                )
+            }
+            HStack {
+                Button("Start private session") { Task { await model.startPrivateBrowser() } }
+                    .buttonStyle(.borderedProminent).disabled(model.browserViewerOrigin.isEmpty || model.browserSession != nil)
+                Button("Burn", role: .destructive) { Task { await model.burnPrivateBrowser() } }
+                    .disabled(model.browserSession == nil)
+            }
+            .padding(.bottom)
+        }
+        .navigationTitle("Private browser")
+        .navigationBarTitleDisplayMode(.inline)
+        .enigmaCanvas()
+        .onDisappear { if model.browserSession != nil { Task { await model.burnPrivateBrowser() } } }
+    }
+
+    private func sameOrigin(_ left: URL, _ right: URL) -> Bool {
+        left.scheme == right.scheme && left.host == right.host && left.port == right.port && left.user == nil && left.password == nil
+    }
+}
+
+private struct EphemeralBrowserView: UIViewRepresentable {
+    let url: URL
+    let allowedOrigin: URL
+
+    func makeCoordinator() -> Coordinator { Coordinator(origin: allowedOrigin) }
+
+    func makeUIView(context: Context) -> WKWebView {
+        let configuration = WKWebViewConfiguration()
+        configuration.websiteDataStore = .nonPersistent()
+        configuration.defaultWebpagePreferences.allowsContentJavaScript = true
+        let view = WKWebView(frame: .zero, configuration: configuration)
+        view.navigationDelegate = context.coordinator
+        view.allowsLinkPreview = false
+        view.load(URLRequest(url: url, cachePolicy: .reloadIgnoringLocalCacheData))
+        return view
+    }
+
+    func updateUIView(_ view: WKWebView, context: Context) {
+        if view.url != url { view.load(URLRequest(url: url, cachePolicy: .reloadIgnoringLocalCacheData)) }
+    }
+
+    static func dismantleUIView(_ view: WKWebView, coordinator: Coordinator) {
+        view.stopLoading()
+        view.configuration.websiteDataStore.removeData(ofTypes: WKWebsiteDataStore.allWebsiteDataTypes(), modifiedSince: .distantPast) {}
+    }
+
+    final class Coordinator: NSObject, WKNavigationDelegate {
+        let origin: URL
+        init(origin: URL) { self.origin = origin }
+        func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
+            guard let url = navigationAction.request.url else { decisionHandler(.cancel); return }
+            let allowed = url.scheme == origin.scheme && url.host == origin.host && url.port == origin.port && url.user == nil && url.password == nil
+            decisionHandler(allowed ? .allow : .cancel)
+        }
+    }
+}

package/apps/ios/EnigmaIOS/Enigma/SecureStore.swift

@@ -0,0 +1,76 @@
+import Foundation
+import Security
+
+struct OAuthCredential: Codable, Sendable {
+    let accessToken: String
+    let refreshToken: String?
+    let expiresAt: Date
+    let clientID: String
+    let issuer: URL
+    let resource: URL
+}
+
+enum SecureStoreError: LocalizedError {
+    case osStatus(OSStatus)
+
+    var errorDescription: String? {
+        switch self {
+        case let .osStatus(status): return "Keychain operation failed (\(status))."
+        }
+    }
+}
+
+struct SecureStore: Sendable {
+    let service: String
+
+    init(service: String = "com.enigmamemory.ios") {
+        self.service = service
+    }
+
+    func set(_ data: Data, account: String) throws {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: account,
+        ]
+        SecItemDelete(query as CFDictionary)
+        var insertion = query
+        insertion[kSecValueData as String] = data
+        insertion[kSecAttrAccessible as String] = kSecAttrAccessibleWhenUnlockedThisDeviceOnly
+        let status = SecItemAdd(insertion as CFDictionary, nil)
+        guard status == errSecSuccess else { throw SecureStoreError.osStatus(status) }
+    }
+
+    func data(account: String) throws -> Data? {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: account,
+            kSecReturnData as String: true,
+            kSecMatchLimit as String: kSecMatchLimitOne,
+        ]
+        var result: CFTypeRef?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        if status == errSecItemNotFound { return nil }
+        guard status == errSecSuccess, let data = result as? Data else { throw SecureStoreError.osStatus(status) }
+        return data
+    }
+
+    func remove(account: String) throws {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: account,
+        ]
+        let status = SecItemDelete(query as CFDictionary)
+        guard status == errSecSuccess || status == errSecItemNotFound else { throw SecureStoreError.osStatus(status) }
+    }
+
+    func setString(_ value: String, account: String) throws {
+        try set(Data(value.utf8), account: account)
+    }
+
+    func string(account: String) throws -> String? {
+        try data(account: account).flatMap { String(data: $0, encoding: .utf8) }
+    }
+}

package/apps/ios/EnigmaIOS/Enigma/SettingsView.swift

@@ -0,0 +1,60 @@
+import SwiftUI
+
+struct SettingsView: View {
+    @EnvironmentObject private var model: AppModel
+    @State private var server = ""
+    @State private var issuer = ""
+    @State private var clientID = ""
+    @State private var resource = ""
+    @State private var viewerOrigin = ""
+
+    var body: some View {
+        Form {
+            Section("Connection") {
+                field("Server", text: $server)
+                field("OAuth issuer", text: $issuer)
+                field("OAuth client ID (optional with approved registration)", text: $clientID)
+                field("Protected resource", text: $resource)
+                Button("Save connection") {
+                    model.configure(server: server, issuer: issuer, clientID: clientID, resource: resource)
+                    model.setBrowserViewerOrigin(viewerOrigin)
+                }
+                Button("Reconnect with OAuth PKCE") {
+                    model.configure(server: server, issuer: issuer, clientID: clientID, resource: resource)
+                    model.setBrowserViewerOrigin(viewerOrigin)
+                    Task { await model.connectWithOAuth() }
+                }
+            }
+            Section("Private browser proof boundary") {
+                field("Signed viewer origin", text: $viewerOrigin)
+                Text("The app accepts only HTTPS stream URLs at this exact origin. The browser uses a non-persistent WKWebView, receives no Enigma OAuth token, rejects cross-origin top-level navigation, and burns on exit.")
+                    .font(.footnote).foregroundStyle(EnigmaTheme.secondary)
+            }
+            Section("Custody") {
+                Label("OAuth and credits access tokens: Keychain, this device only", systemImage: "key.fill")
+                Label("Conversation: process memory only", systemImage: "memorychip")
+                Label("Recovery code: shown once, never saved automatically", systemImage: "doc.on.clipboard")
+            }
+            Section {
+                Button("Disconnect and clear OAuth credentials", role: .destructive) { Task { await model.disconnect() } }
+            }
+        }
+        .navigationTitle("Connection")
+        .onAppear {
+            server = model.serverAddress
+            issuer = model.oauthIssuer
+            clientID = model.oauthClientID
+            resource = model.oauthResource
+            viewerOrigin = model.browserViewerOrigin
+        }
+    }
+
+    private func field(_ label: String, text: Binding<String>) -> some View {
+        VStack(alignment: .leading, spacing: 5) {
+            Text(label).font(.caption).foregroundStyle(EnigmaTheme.muted)
+            TextField(label, text: text)
+                .textInputAutocapitalization(.never)
+                .autocorrectionDisabled()
+        }
+    }
+}

package/apps/ios/EnigmaIOS/Enigma/Theme.swift

@@ -0,0 +1,80 @@
+import SwiftUI
+
+enum EnigmaTheme {
+    static let canvas = Color(red: 0.976, green: 0.969, blue: 0.949)
+    static let surface = Color.white.opacity(0.82)
+    static let ink = Color(red: 0.13, green: 0.12, blue: 0.105)
+    static let secondary = Color(red: 0.42, green: 0.40, blue: 0.36)
+    static let muted = Color(red: 0.58, green: 0.55, blue: 0.50)
+    static let line = Color(red: 0.87, green: 0.85, blue: 0.81)
+    static let ember = Color(red: 0.94, green: 0.30, blue: 0.11)
+    static let success = Color(red: 0.22, green: 0.45, blue: 0.31)
+
+    static let display = Font.system(.largeTitle, design: .serif, weight: .medium)
+    static let title = Font.system(.title2, design: .serif, weight: .medium)
+    static let body = Font.system(.body, design: .rounded)
+    static let label = Font.system(.caption2, design: .monospaced, weight: .semibold)
+}
+
+struct EnigmaCanvas: ViewModifier {
+    func body(content: Content) -> some View {
+        content
+            .foregroundStyle(EnigmaTheme.ink)
+            .background(EnigmaTheme.canvas.ignoresSafeArea())
+            .tint(EnigmaTheme.ember)
+    }
+}
+
+extension View {
+    func enigmaCanvas() -> some View { modifier(EnigmaCanvas()) }
+
+    func enigmaSurface(padding: CGFloat = 16) -> some View {
+        self.padding(padding)
+            .background(EnigmaTheme.surface)
+            .overlay(RoundedRectangle(cornerRadius: 12).stroke(EnigmaTheme.line, lineWidth: 0.8))
+            .clipShape(RoundedRectangle(cornerRadius: 12))
+    }
+}
+
+struct EnigmaMark: View {
+    var size: CGFloat = 22
+
+    var body: some View {
+        ZStack {
+            ForEach(0..<12, id: \.self) { index in
+                Capsule()
+                    .fill(EnigmaTheme.ember)
+                    .frame(width: size * 0.11, height: size * 0.44)
+                    .offset(y: -size * 0.29)
+                    .rotationEffect(.degrees(Double(index) * 30))
+            }
+            Circle().fill(EnigmaTheme.canvas).frame(width: size * 0.22, height: size * 0.22)
+        }
+        .frame(width: size, height: size)
+        .accessibilityHidden(true)
+    }
+}
+
+struct SectionEyebrow: View {
+    let text: String
+    var body: some View {
+        Text(text.uppercased())
+            .font(EnigmaTheme.label)
+            .tracking(1.6)
+            .foregroundStyle(EnigmaTheme.ember)
+    }
+}
+
+struct PrimaryButtonStyle: ButtonStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        configuration.label
+            .font(.system(.subheadline, design: .rounded, weight: .semibold))
+            .frame(maxWidth: .infinity)
+            .padding(.vertical, 13)
+            .foregroundStyle(.white)
+            .background(EnigmaTheme.ember.opacity(configuration.isPressed ? 0.78 : 1))
+            .clipShape(RoundedRectangle(cornerRadius: 10))
+            .scaleEffect(configuration.isPressed ? 0.985 : 1)
+            .animation(.easeOut(duration: 0.12), value: configuration.isPressed)
+    }
+}