My Translation Prototype Worked as an App. Rebuilds Kept Breaking Its Permission.

My translation prototype had two problems that looked unrelated. The bare executable returned TranslationError.internalError. After I packaged the app, rebuilding it kept disturbing its screen-recording permission.

I was trying to make a local screen translator. Instead, I was repeatedly teaching the operating system which app I’d just built. The cost wasn’t a measured number of minutes. It was a development loop that couldn’t keep its permission state.

These are my June 17, 2026 notes from an Apple Silicon Mac. I haven’t rerun that old setup against every later macOS release. This is the packaging and identity problem I encountered, not a claim that every translation error has the same cause.

Two failures, two checks

The prototype used ScreenCaptureKit for screenshots, Vision for OCR, and Apple’s Translation framework. AI helped with the implementation; I checked the resulting build and runtime behavior.

The first failure happened before a useful translation came back. Running a bare binary produced the internal-error message. A signed .app bundle with a bundle identifier was the working arrangement recorded in my notes.

That doesn’t tell me which individual packaging property fixed it. I didn’t run a controlled matrix of bundle identifiers, entitlements, signatures, and launch methods. I know the unsuccessful arrangement and the working one. I won’t turn those two observations into a universal framework requirement.

The second failure appeared during rebuilds. My ad-hoc signing path didn’t preserve the screen-recording authorization as I expected. Using a fixed Apple Development signing identity gave me a repeatable build path with the permission retained in the recorded checks.

June 17 check Recorded result What I can conclude
Bare executable Translation internal error That launch arrangement failed
Signed app bundle Runtime smoke check passed The packaged arrangement worked
Ad-hoc signing during rebuilds Screen-recording permission needed attention again My rebuild loop wasn’t preserving authorization
Fixed development identity Permission retained in the recorded workflow A stable signing arrangement solved my local loop

I didn’t keep a rebuild count. There’s no percentage improvement hiding in this table.

I had treated the executable as the whole app

The Swift file was the part I could see changing. That made it tempting to debug only the Swift file.

But the operating system also saw a bundle, an identifier, a signature, and a request for screen access. Those weren’t decoration around the code. They were inputs to how the app ran.

Apple’s archived code-signing technical note describes designated requirements as a way to identify code across updates. It doesn’t establish the exact TCC decision in my incident. I didn’t capture the policy trace needed to claim that.

My practical change was smaller: keep the bundle identity and signing choice stable, then launch the finished app. I stopped treating packaging as something to add after the prototype worked.

The checks I’d preserve on another run

I’d record the macOS build and the app’s bundle identifier first. My old note didn’t retain the exact OS build, which limits reproduction now.

Then I’d keep the signed bundle from before a change. I’d record the signing requirement and the screen-recording permission state, rebuild once, and compare them. That’s a proposed repeatable check, not a test I’m claiming to have run today.

I’d also separate three questions:

  • Can the app capture the selected region?
  • Can Translation prepare its language resources and return text?
  • Does the next build keep the authorization I already granted?

A translation failure doesn’t answer the capture question. A successful capture doesn’t prove the translation path works. And neither proves the next build will keep its identity.

Don’t reset permissions before preserving the evidence

My notes include an app-specific screen-capture permission reset as a recovery step. I wouldn’t start there now. A reset changes the state I’m trying to understand, and it can make the next launch look like a clean first install.

I also wouldn’t copy somebody else’s signing identity into my build. The useful part is the stable identity in my own environment. It isn’t a certificate string from a blog post.

This isn’t a notarization or public-distribution recipe. I was building a local prototype, and I didn’t test another user’s installation. Keeping a development permission working says nothing about whether a distributed app will pass every trust check.

What remained unfinished

The June record says the build and runtime smoke check passed. Overlay alignment and perceived speed still needed visual confirmation. Multi-display handling and the audio channel were later stages, not features proved by this fix.

That’s where I stop the claim. My app could get through its packaging and permission loop. I hadn’t finished a polished translator.

I later hit a different translation problem: the output could arrive successfully and still reverse the meaning of a sentence. Getting the process to run and trusting its answer turned out to be separate jobs.

Similar Posts