From d2b885b3fc0afed6d308b578e32e826f8913e51c Mon Sep 17 00:00:00 2001
From: prompt.ac/@jeffrey <mail@aesthetic.computer>
Date: Wed, 15 Jul 2026 19:17:01 +0000
Subject: [PATCH] menuband: build take DMG in temp then move to Desktop + ready chime

The Desktop no longer shows a half-written / cover-less file mid-build: the
staging dir AND the .dmg are assembled in one temp work dir, the cover is
stamped there (waiting for the async resource-fork write to land), then the
finished artifact is moved onto the Desktop in one step. A short crystalline
ReadyChime (self-contained bell arpeggio, like CountInWhoosh) rings when the
DMG lands.
---
 slab/menuband/Sources/MenuBand/MenuBandController.swift | 4 +++-
 slab/menuband/Sources/MenuBand/ReadyChime.swift | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 slab/menuband/Sources/MenuBand/TakeDMG.swift | 46 ++++++++++++++++++++++++++++++++++++----------
 3 file(s) changed, 107 insertion(s)(+), 11 deletion(s)(-)

diff --git a/slab/menuband/Sources/MenuBand/MenuBandController.swift b/slab/menuband/Sources/MenuBand/MenuBandController.swift
--- a/slab/menuband/Sources/MenuBand/MenuBandController.swift
+++ b/slab/menuband/Sources/MenuBand/MenuBandController.swift
@@ -1453,7 +1453,9 @@ // The sidecar .mid (editable notes for Ableton) rides inside the DMG.
         let extras = [take.midi].compactMap { $0 }
         // DMG only — the .mbtape (zip) alternative is dropped. `buildMbtape`
         // stays in TakeDMG if we ever want to flag it back on.
-        return TakeDMG.build(wav: src, extras: extras, name: name, coverIcon: cover)
+        let dmg = TakeDMG.build(wav: src, extras: extras, name: name, coverIcon: cover)
+        if dmg != nil { ReadyChime.shared.play() }   // cool "release" chime when the artifact lands
+        return dmg
     }
 
     /// State-change observer. Drops the pins whenever the tape goes
diff --git a/slab/menuband/Sources/MenuBand/ReadyChime.swift b/slab/menuband/Sources/MenuBand/ReadyChime.swift
new file mode 100644
--- /dev/null
+++ b/slab/menuband/Sources/MenuBand/ReadyChime.swift
@@ -0,0 +1,68 @@
+import AVFoundation
+
+/// A short crystalline "release" chime — a rising bell arpeggio that rings when
+/// a finished take DMG lands on the Desktop. Runs on its own tiny engine so it
+/// never touches the instrument's audio graph (mirrors `CountInWhoosh`).
+final class ReadyChime {
+    static let shared = ReadyChime()
+
+    private let engine = AVAudioEngine()
+    private let player = AVAudioPlayerNode()
+    private let sampleRate = 44_100.0
+    private var started = false
+
+    private func ensureStarted() {
+        guard !started else { return }
+        engine.attach(player)
+        guard let fmt = AVAudioFormat(standardFormatWithSampleRate: sampleRate, channels: 2) else { return }
+        engine.connect(player, to: engine.mainMixerNode, format: fmt)
+        do { try engine.start(); started = true }
+        catch { NSLog("ReadyChime: engine start failed — \(error)") }
+    }
+
+    /// Ring it: a staggered bell arpeggio spelling a bright D major add-shimmer,
+    /// each note a decaying sine + a glassy 2nd partial, panned to fan out.
+    func play() {
+        ensureStarted()
+        guard started,
+              let fmt = AVAudioFormat(standardFormatWithSampleRate: sampleRate, channels: 2)
+        else { return }
+
+        let dur = 1.4
+        let n = Int(sampleRate * dur)
+        guard let buf = AVAudioPCMBuffer(pcmFormat: fmt, frameCapacity: AVAudioFrameCount(n)),
+              let left = buf.floatChannelData?[0],
+              let right = buf.floatChannelData?[1]
+        else { return }
+        buf.frameLength = AVAudioFrameCount(n)
+
+        struct Bell { let freq: Double; let start: Double; let pan: Double }
+        let bells: [Bell] = [
+            Bell(freq:  587.33, start: 0.00, pan: -0.35),  // D5
+            Bell(freq:  739.99, start: 0.08, pan: -0.10),  // F#5
+            Bell(freq:  880.00, start: 0.16, pan:  0.15),  // A5
+            Bell(freq: 1174.66, start: 0.26, pan:  0.35),  // D6 shimmer
+        ]
+        let twoPi = 2.0 * Double.pi
+        for i in 0..<n {
+            let t = Double(i) / sampleRate
+            var l = 0.0, r = 0.0
+            for b in bells {
+                let dt = t - b.start
+                if dt < 0 { continue }
+                let env = exp(-dt * 3.0)                       // bell-like decay
+                let s = sin(twoPi * b.freq * dt) * 0.6
+                      + sin(twoPi * b.freq * 2 * dt) * 0.16    // glassy overtone
+                let amp = env * 0.30
+                l += s * amp * (0.5 - b.pan * 0.5)
+                r += s * amp * (0.5 + b.pan * 0.5)
+            }
+            left[i]  = Float(l)
+            right[i] = Float(r)
+        }
+
+        player.stop()
+        player.scheduleBuffer(buf, at: nil, options: [], completionHandler: nil)
+        player.play()
+    }
+}
diff --git a/slab/menuband/Sources/MenuBand/TakeDMG.swift b/slab/menuband/Sources/MenuBand/TakeDMG.swift
--- a/slab/menuband/Sources/MenuBand/TakeDMG.swift
+++ b/slab/menuband/Sources/MenuBand/TakeDMG.swift
@@ -18,8 +18,13 @@ let desktop = fm.urls(for: .desktopDirectory, in: .userDomainMask).first
             ?? fm.homeDirectoryForCurrentUser.appendingPathComponent("Desktop")
         let out = uniqueURL(desktop.appendingPathComponent("\(name).dmg"))
 
-        let stage = fm.temporaryDirectory.appendingPathComponent("mbtake-\(UUID().uuidString)")
-        defer { try? fm.removeItem(at: stage) }
+        // Everything is built inside one temp work dir — staging AND the .dmg
+        // itself — so the Desktop never shows a half-written / cover-less file.
+        // Only the finished, cover-stamped artifact is moved onto the Desktop.
+        let work = fm.temporaryDirectory.appendingPathComponent("mbtake-\(UUID().uuidString)")
+        let stage = work.appendingPathComponent("stage")
+        let tmpDMG = work.appendingPathComponent("\(name).dmg")
+        defer { try? fm.removeItem(at: work) }
 
         do {
             try fm.createDirectory(at: stage, withIntermediateDirectories: true)
@@ -45,20 +50,25 @@ if let icns = Bundle.appResources.url(forResource: "AppIcon", withExtension: "icns") {
                 try? fm.copyItem(at: icns, to: stage.appendingPathComponent(".VolumeIcon.icns"))
             }
 
-            // ONE step: compressed read-only image straight from the folder.
-            // No mount → no stray Desktop volume, and ~1 hdiutil call instead of
-            // four (create RW → attach → detach → convert), so it's quick.
-            try? fm.removeItem(at: out)
+            // ONE step: compressed read-only image straight from the folder,
+            // written to the TEMP work dir (not the Desktop).
             guard run("/usr/bin/hdiutil",
                       ["create", "-srcfolder", stage.path, "-volname", name,
-                       "-fs", "HFS+", "-format", "UDZO", "-ov", "-quiet", out.path])
+                       "-fs", "HFS+", "-format", "UDZO", "-ov", "-quiet", tmpDMG.path])
             else { return nil }
 
-            // The album-art cover on the .dmg FILE itself (what shows on the
-            // Desktop / in Messages).
+            // Stamp the album-art cover on the temp .dmg, then wait for the icon
+            // write to actually land (NSWorkspace.setIcon flushes the resource
+            // fork asynchronously) so the file is COMPLETE before it moves.
             if let cover = coverIcon {
-                NSWorkspace.shared.setIcon(cover, forFile: out.path, options: [])
+                NSWorkspace.shared.setIcon(cover, forFile: tmpDMG.path, options: [])
+                waitForResourceFork(tmpDMG, minBytes: 4096, timeout: 1.5)
             }
+
+            // Move the finished, cover-stamped artifact onto the Desktop in one
+            // step — the Desktop only ever sees the completed record.
+            try? fm.removeItem(at: out)
+            try fm.moveItem(at: tmpDMG, to: out)
             NSLog("MenuBand TakeDMG: \(out.path)")
             return out
         } catch {
@@ -85,6 +95,22 @@ NSWorkspace.shared.setIcon(cover, forFile: out.path, options: [])
         }
         NSLog("MenuBand mbtape: \(out.path)")
         return out
+    }
+
+    /// Block (off the main thread) until a custom-icon resource fork of at least
+    /// `minBytes` has been written — `NSWorkspace.setIcon` flushes it
+    /// asynchronously, so this prevents moving a file whose icon is half-written.
+    private static func waitForResourceFork(_ url: URL, minBytes: Int, timeout: TimeInterval) {
+        let key = "com.apple.ResourceFork"
+        let deadline = Date().addingTimeInterval(timeout)
+        repeat {
+            let size = url.withUnsafeFileSystemRepresentation { path -> Int in
+                guard let path = path else { return 0 }
+                return max(0, getxattr(path, key, nil, 0, 0, 0))
+            }
+            if size >= minBytes { return }
+            usleep(20_000)   // 20 ms
+        } while Date() < deadline
     }
 
     @discardableResult

--
tangled.sh