@geastack/apple 0.2.8

package/targets/macos/prune-generated-modules.mjs

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+const args = new Set(process.argv.slice(2))
+const outArgIndex = process.argv.indexOf('--out-dir')
+const outDirValue = outArgIndex >= 0 ? process.argv[outArgIndex + 1] : ''
+const dryRun = args.has('--dry-run')
+
+if (!outDirValue) {
+  process.stderr.write('usage: prune-generated-modules.mjs --out-dir <generated-dir> [--dry-run]\n')
+  process.exit(1)
+}
+
+const outDir = path.resolve(outDirValue)
+const modulesDir = path.join(outDir, 'modules')
+const sourceListPath = path.join(outDir, 'geatsc-sources.txt')
+const ownedManifestPath = path.join(outDir, '.gea-owned-modules.json')
+
+if (!fs.existsSync(modulesDir) || !fs.existsSync(sourceListPath)) {
+  process.stdout.write(`${JSON.stringify({ activeFamilies: 0, keptFiles: 0, removedFiles: 0 })}\n`)
+  process.exit(0)
+}
+
+const ownedModulePattern = /^(?:\d{4}_.+\.(?:cpp|hpp|types\.hpp)|__gea_data_batch_\d{4}\.cpp)$/
+
+function familyOf(filename) {
+  return filename.replace(/\.types\.hpp$|\.hpp$|\.cpp$/, '')
+}
+
+function familyFiles(family) {
+  return [`${family}.cpp`, `${family}.hpp`, `${family}.types.hpp`]
+}
+
+function isInside(parent, candidate) {
+  const relative = path.relative(parent, candidate)
+  return relative !== '' && !relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative)
+}
+
+// A killed prior prune may have moved only part of its stale set. Restore that
+// set before making a new plan; active files therefore never depend on the
+// precise point at which the previous process died.
+if (!dryRun) {
+  for (const entry of fs.readdirSync(outDir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !entry.name.startsWith('.gea-prune-quarantine-')) continue
+    const quarantine = path.join(outDir, entry.name)
+    for (const filename of fs.readdirSync(quarantine)) {
+      const source = path.join(quarantine, filename)
+      const destination = path.join(modulesDir, filename)
+      if (!fs.existsSync(destination)) fs.renameSync(source, destination)
+      else fs.rmSync(source, { force: true })
+    }
+    fs.rmdirSync(quarantine)
+  }
+}
+
+const listedSources = fs.readFileSync(sourceListPath, 'utf8').split(/\r?\n/).filter(Boolean)
+const activeFamilies = new Set()
+for (const source of listedSources) {
+  const resolved = path.resolve(source)
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`Refusing to prune: active source is missing: ${resolved}`)
+  }
+  if (path.dirname(resolved) === modulesDir && resolved.endsWith('.cpp')) {
+    activeFamilies.add(familyOf(path.basename(resolved)))
+  }
+}
+
+const moduleEntries = new Set(fs.readdirSync(modulesDir, { withFileTypes: true })
+  .filter((entry) => entry.isFile())
+  .map((entry) => entry.name))
+const keptFiles = new Set()
+const scanQueue = []
+
+function keepFile(filename) {
+  if (!moduleEntries.has(filename) || keptFiles.has(filename)) return
+  keptFiles.add(filename)
+  scanQueue.push(filename)
+}
+
+function keepFamily(family) {
+  for (const filename of familyFiles(family)) keepFile(filename)
+}
+
+for (const family of activeFamilies) keepFamily(family)
+
+// Follow local quoted includes from every active family. This is the safety
+// valve for a genuinely header-only generated support family: it remains even
+// though it has no entry in geatsc-sources.txt.
+const includePattern = /^\s*#\s*include\s+"([^"]+)"/gm
+for (let index = 0; index < scanQueue.length; index += 1) {
+  const filename = scanQueue[index]
+  const filePath = path.join(modulesDir, filename)
+  const contents = fs.readFileSync(filePath, 'utf8')
+  includePattern.lastIndex = 0
+  let match
+  while ((match = includePattern.exec(contents)) !== null) {
+    const included = path.resolve(path.dirname(filePath), match[1])
+    if (!isInside(modulesDir, included) || !fs.existsSync(included)) continue
+    const includedName = path.basename(included)
+    keepFile(includedName)
+    keepFamily(familyOf(includedName))
+  }
+}
+
+const ownedFiles = [...moduleEntries].filter((filename) => ownedModulePattern.test(filename)).sort()
+const staleFiles = ownedFiles.filter((filename) => !keptFiles.has(filename))
+const remainingOwnedFiles = ownedFiles.filter((filename) => keptFiles.has(filename))
+
+const result = {
+  activeFamilies: activeFamilies.size,
+  keptFiles: keptFiles.size,
+  removedFiles: staleFiles.length,
+  staleFiles,
+}
+
+if (dryRun) {
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`)
+  process.exit(0)
+}
+
+const quarantine = path.join(outDir, `.gea-prune-quarantine-${process.pid}`)
+fs.mkdirSync(quarantine)
+const moved = []
+try {
+  for (const filename of staleFiles) {
+    fs.renameSync(path.join(modulesDir, filename), path.join(quarantine, filename))
+    moved.push(filename)
+  }
+
+  const manifest = `${JSON.stringify({ version: 1, files: remainingOwnedFiles }, null, 2)}\n`
+  const manifestTemporary = `${ownedManifestPath}.tmp.${process.pid}`
+  fs.writeFileSync(manifestTemporary, manifest)
+  fs.renameSync(manifestTemporary, ownedManifestPath)
+  fs.rmSync(quarantine, { recursive: true, force: true })
+} catch (error) {
+  for (const filename of moved.reverse()) {
+    const source = path.join(quarantine, filename)
+    const destination = path.join(modulesDir, filename)
+    if (fs.existsSync(source) && !fs.existsSync(destination)) fs.renameSync(source, destination)
+  }
+  fs.rmSync(quarantine, { recursive: true, force: true })
+  throw error
+}
+
+process.stdout.write(`${JSON.stringify(result)}\n`)

package/targets/macos/sync-resources.mjs

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+const args = process.argv.slice(2)
+
+function values(name) {
+  const out = []
+  const prefix = `${name}=`
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] === name) out.push(args[index + 1] || '')
+    else if (args[index].startsWith(prefix)) out.push(args[index].slice(prefix.length))
+  }
+  return out.filter(Boolean)
+}
+
+function value(name) {
+  return values(name).at(-1) || ''
+}
+
+function fail(message) {
+  process.stderr.write(`${message}\n`)
+  process.exit(1)
+}
+
+const resourcesDir = path.resolve(value('--resources-dir') || '')
+const manifestPath = path.resolve(value('--manifest') || '')
+const configDir = value('--config-dir') ? path.resolve(value('--config-dir')) : ''
+const appDirs = values('--app-dir').map((item) => path.resolve(item))
+const sharedCssDirs = values('--shared-css-dir').map((item) => path.resolve(item))
+
+if (!value('--resources-dir') || !value('--manifest')) {
+  fail('usage: sync-resources.mjs --resources-dir <dir> --manifest <file> [--config-dir <dir>] [--app-dir <dir> ...] [--shared-css-dir <dir> ...]')
+}
+
+fs.mkdirSync(resourcesDir, { recursive: true })
+
+let changed = false
+
+function sameFileContent(source, destination) {
+  if (!fs.existsSync(destination)) return false
+  const sourceStat = fs.statSync(source)
+  const destinationStat = fs.statSync(destination)
+  if (sourceStat.size !== destinationStat.size) return false
+  return fs.readFileSync(source).equals(fs.readFileSync(destination))
+}
+
+function syncFile(source, destination) {
+  if (sameFileContent(source, destination)) return
+  fs.mkdirSync(path.dirname(destination), { recursive: true })
+  const temporary = `${destination}.tmp.${process.pid}`
+  fs.copyFileSync(source, temporary)
+  fs.renameSync(temporary, destination)
+  changed = true
+}
+
+function removeFile(file) {
+  try {
+    fs.lstatSync(file)
+  } catch (error) {
+    if (error?.code === 'ENOENT') return
+    throw error
+  }
+  fs.rmSync(file, { force: true })
+  changed = true
+}
+
+function isSafeBasename(value) {
+  return value !== '.' && value !== '..' && path.basename(value) === value && !value.includes('/') && !value.includes('\\')
+}
+
+function walkCss(root, visit) {
+  if (!root || !fs.existsSync(root)) return
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    if (entry.name === 'node_modules' || entry.name === 'dist') continue
+    const full = path.join(root, entry.name)
+    if (entry.isDirectory()) walkCss(full, visit)
+    else if (entry.isFile() && entry.name.endsWith('.css')) visit(full)
+  }
+}
+
+// Match the build's historical first-source-wins behavior for basename
+// collisions, but keep an owned manifest so removed @font-face declarations do
+// not leave stale resources in the app bundle.
+const desiredFonts = new Map()
+for (const root of [...appDirs, ...sharedCssDirs]) {
+  walkCss(root, (cssPath) => {
+    const css = fs.readFileSync(cssPath, 'utf8').replace(/\/\*[\s\S]*?\*\//g, '')
+    const facePattern = /@font-face\s*\{([^}]+)\}/gi
+    let face
+    while ((face = facePattern.exec(css)) !== null) {
+      const source = face[1].match(/src\s*:\s*url\(\s*(?:"([^"]+)"|'([^']+)'|([^)"']+))\s*\)/i)
+      if (!source) continue
+      const raw = (source[1] || source[2] || source[3] || '').trim()
+      if (!raw || /^https?:\/\//i.test(raw) || raw.startsWith('data:')) continue
+      const clean = raw.split(/[?#]/, 1)[0]
+      const resolved = path.resolve(path.dirname(cssPath), clean)
+      if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile()) continue
+      const basename = path.basename(resolved)
+      if (!desiredFonts.has(basename)) desiredFonts.set(basename, resolved)
+    }
+  })
+}
+
+let previousFonts = []
+try {
+  const previous = JSON.parse(fs.readFileSync(manifestPath, 'utf8'))
+  if (Array.isArray(previous.fonts)) {
+    previousFonts = previous.fonts.filter((item) => typeof item === 'string' && isSafeBasename(item))
+  }
+} catch {
+  // A missing/old manifest simply means there are no previously-owned fonts.
+}
+
+const fontsDir = path.join(resourcesDir, 'Fonts')
+// Fonts/ is wholly owned by this stage. Removing every undesired regular entry
+// also cleans resources left by builds from before the ownership manifest was
+// introduced and temporary files left by a killed copy.
+if (fs.existsSync(fontsDir)) {
+  for (const entry of fs.readdirSync(fontsDir, { withFileTypes: true })) {
+    if ((entry.isFile() || entry.isSymbolicLink()) && !desiredFonts.has(entry.name)) {
+      removeFile(path.join(fontsDir, entry.name))
+    }
+  }
+}
+for (const basename of previousFonts) {
+  if (!desiredFonts.has(basename) && isSafeBasename(basename)) removeFile(path.join(fontsDir, basename))
+}
+for (const [basename, source] of desiredFonts) {
+  syncFile(source, path.join(fontsDir, basename))
+}
+if (fs.existsSync(fontsDir) && fs.readdirSync(fontsDir).length === 0) {
+  fs.rmdirSync(fontsDir)
+}
+
+const windowConfig = path.join(resourcesDir, 'window.json')
+for (const entry of fs.readdirSync(resourcesDir, { withFileTypes: true })) {
+  if (entry.isFile() && /^window\.json\.tmp\.\d+$/.test(entry.name)) removeFile(path.join(resourcesDir, entry.name))
+}
+const configSource = configDir ? path.join(configDir, 'macos.json') : ''
+if (configSource && fs.existsSync(configSource)) syncFile(configSource, windowConfig)
+else removeFile(windowConfig)
+
+const manifest = `${JSON.stringify({ fonts: [...desiredFonts.keys()].sort() }, null, 2)}\n`
+fs.mkdirSync(path.dirname(manifestPath), { recursive: true })
+if (!fs.existsSync(manifestPath) || fs.readFileSync(manifestPath, 'utf8') !== manifest) {
+  const temporary = `${manifestPath}.tmp.${process.pid}`
+  fs.writeFileSync(temporary, manifest)
+  fs.renameSync(temporary, manifestPath)
+}
+
+process.stdout.write(changed ? 'changed=1\n' : 'changed=0\n')

package/targets/shared/analyze-audio-capture.mjs

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+// Measures a capture produced by GEA_AUDIO_CAPTURE_RAW (see apple_audio.mm):
+// raw interleaved float32 stereo at 48 kHz, written by the audio backend while a
+// real app runs. Reports level, note onsets and the measured fundamental of each
+// note, so "the app really made sound" is a measurement rather than a claim.
+//
+//   node analyze-audio-capture.mjs <capture.f32> [--rate 48000] [--notes 20]
+
+import { readFileSync } from 'node:fs'
+
+const args = process.argv.slice(2)
+const path = args.find((a) => !a.startsWith('--'))
+if (!path) {
+  console.error('usage: analyze-audio-capture.mjs <capture.f32> [--rate 48000] [--notes 20]')
+  process.exit(2)
+}
+const option = (name, fallback) => {
+  const index = args.indexOf(`--${name}`)
+  return index >= 0 && args[index + 1] ? Number(args[index + 1]) : fallback
+}
+const rate = option('rate', 48000)
+const maxNotes = option('notes', 20)
+
+const bytes = readFileSync(path)
+const samples = new Float32Array(bytes.buffer, bytes.byteOffset, Math.floor(bytes.length / 4))
+const frames = Math.floor(samples.length / 2)
+const left = new Float32Array(frames)
+for (let frame = 0; frame < frames; frame++) left[frame] = samples[frame * 2]
+
+const rms = (from, to) => {
+  let sum = 0
+  for (let i = from; i < to; i++) sum += left[i] * left[i]
+  return Math.sqrt(sum / Math.max(1, to - from))
+}
+const peak = (from, to) => {
+  let worst = 0
+  for (let i = from; i < to; i++) worst = Math.max(worst, Math.abs(left[i]))
+  return worst
+}
+// Fundamental by hysteretic zero crossings — exact enough for the synth's
+// single-tone output.
+const frequency = (from, to) => {
+  const threshold = 0.15 * peak(from, to)
+  if (threshold <= 0) return 0
+  let sign = 0
+  let crossings = 0
+  let first = 0
+  let last = 0
+  for (let i = from; i < to; i++) {
+    const value = left[i]
+    let next = sign
+    if (value > threshold) next = 1
+    else if (value < -threshold) next = -1
+    if (next !== sign && sign !== 0) {
+      if (crossings === 0) first = i
+      last = i
+      crossings++
+    }
+    sign = next
+  }
+  if (crossings < 3 || last <= first) return 0
+  return (crossings - 1) / (2 * ((last - first) / rate))
+}
+
+// Envelope-follow in 1 ms hops; a note is a run above the gate.
+const hop = Math.max(1, Math.round(rate / 1000))
+const hops = Math.floor(frames / hop)
+const envelope = new Float64Array(hops)
+for (let h = 0; h < hops; h++) envelope[h] = rms(h * hop, (h + 1) * hop)
+const loudest = envelope.reduce((a, b) => Math.max(a, b), 0)
+const gate = Math.max(1e-4, loudest * 0.1)
+
+const notes = []
+let start = -1
+for (let h = 0; h < hops; h++) {
+  const loud = envelope[h] > gate
+  if (loud && start < 0) start = h
+  if (!loud && start >= 0) {
+    if (h - start >= 8) notes.push([start, h])
+    start = -1
+  }
+}
+if (start >= 0 && hops - start >= 8) notes.push([start, hops])
+
+const soundingHops = envelope.reduce((count, value) => count + (value > gate ? 1 : 0), 0)
+
+console.log(`file            ${path}`)
+console.log(`frames          ${frames} stereo @ ${rate} Hz  (${(frames / rate).toFixed(3)} s)`)
+console.log(`overall rms     ${rms(0, frames).toFixed(6)}`)
+console.log(`peak            ${peak(0, frames).toFixed(6)}`)
+console.log(`sounding        ${((100 * soundingHops) / hops).toFixed(1)}% of the capture`)
+console.log(`silent          ${((100 * (hops - soundingHops)) / hops).toFixed(1)}% of the capture`)
+console.log(`gated runs      ${notes.length} (a legato melody is one run, see the pitch track)`)
+console.log('')
+
+// Pitch track: a melody whose notes butt up against each other never dips below
+// the gate, so segment by PITCH instead. 30 ms windows every 10 ms, merged into
+// runs whose fundamental agrees within 3%.
+const windowFrames = Math.round(0.03 * rate)
+const stepFrames = Math.round(0.01 * rate)
+const track = []
+for (let from = 0; from + windowFrames <= frames; from += stepFrames) {
+  track.push({ from, hz: frequency(from, from + windowFrames), rms: rms(from, from + windowFrames) })
+}
+const runs = []
+for (const point of track) {
+  if (point.hz <= 0 || point.rms <= gate) {
+    runs.push(null)
+    continue
+  }
+  const last = runs.length > 0 ? runs[runs.length - 1] : null
+  if (last && Math.abs(point.hz - last.hz) / last.hz < 0.03) {
+    last.to = point.from + windowFrames
+    last.hz = (last.hz * last.count + point.hz) / (last.count + 1)
+    last.count++
+  } else {
+    runs.push({ from: point.from, to: point.from + windowFrames, hz: point.hz, count: 1 })
+  }
+}
+const melody = runs.filter((run) => run && run.to - run.from >= Math.round(0.05 * rate))
+console.log(`pitch runs      ${melody.length}`)
+console.log('')
+console.log('  #   start(s)  dur(ms)      rms     freq(Hz)')
+for (const [index, run] of melody.slice(0, maxNotes).entries()) {
+  console.log(
+    `  ${String(index + 1).padStart(2)}  ${(run.from / rate).toFixed(4)}  ` +
+      `${String(Math.round((1000 * (run.to - run.from)) / rate)).padStart(6)}  ` +
+      `${rms(run.from, run.to).toFixed(5)}  ${run.hz.toFixed(1).padStart(9)}`,
+  )
+}
+if (melody.length > maxNotes) console.log(`  ... ${melody.length - maxNotes} more`)