snapback4-expo 0.4.12 → 0.4.14

package/README.md

@@ -66,8 +66,13 @@ runner, commands and artifact contract are in `snapback4 guide witness`
 “Proving it on an iOS simulator”. No Expo Go or Metro process supplies a
 Release witness.
 
-At every milestone, `npm run export:ios` keeps Hermes in `dist/` and also proves the app runs on iOS when Xcode/runtime are present (warm runs take about 18 s for the plain starter and 27 s for the social one, cold runs 175–230 s, on this mini).
-`npm run native:smoke` always runs the full Release build; `SNAPBACK4_NATIVE_SMOKE=off` skips the automatic smoke. Unavailable hosts skip, app/SDK failures fail.
+At every milestone, `npm run export:ios` publishes Hermes to `dist/` and returns.
+Native proof runs in the background at background QoS while you keep building.
+The next export and `npx snapback4 doctor` print the result; for your final report
+run `npx snapback4 witness status --wait`. A newer export supersedes pending proof.
+Failures stay visible with log paths without failing a successful export;
+unavailable hosts report a skip. Background preparation allows 900 seconds without output activity and at most 60 minutes total. Activity alone does not establish build progress; repeated output can keep a stalled build occupied until that cap.
+`npm run native:smoke` explicitly waits for the full build and smoke.
 The smoke prepares and installs your Release app, chooses its own simulator and free
 port, and keeps receipts in `artifacts/native-smoke/<timestamp>`. It proves local
 store acquisition, cold offline reopen and reconnect. Pending write replay, media
@@ -95,5 +100,5 @@ After JS edits, repeat `npm run export:ios`; simulator selection and fresh
 artifact directories are automatic. Matching native inputs reuse the Release
 app and install the exact exported bundle/assets. Native changes rebuild;
 `npm run native:smoke` always runs Xcode. Both routes retain the same loaded-file
-hash and prime/offline/restart proof. Measured on the Apartment M5 Pro mini,
-18 cores/64 GiB, Xcode/iOS 27, with tools/dependencies installed first.
+hash and prime/offline/restart proof. Automatic smoke creates and removes its own
+recorded simulator, with project and device leases held through cleanup.

package/export-ios.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-// @ref LLP 3000.030#15 — exact export, explicit environment skips, bounded evidence.
+// @ref LLP 3000.030#15 — publish Hermes first; detached proof retains its exact snapshot.
 import { spawn, spawnSync } from 'node:child_process';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import fs from 'node:fs';
 import { pathToFileURL } from 'node:url';
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
 
 const sha256 = bytes => createHash('sha256').update(bytes).digest('hex');
@@ -36,6 +36,18 @@ export function verifyPublication(artifacts, source, target, expected) {
   }
 }
 
+// The marker is part of the atomically published inventory. A fresh generation
+// distinguishes equal-byte exports and survives a failed latest.json handoff.
+const publicationMarker = '.snapback4-publication.json';
+function markPublication(root, skip) {
+  const metadata = JSON.parse(fs.readFileSync(path.join(root, 'metadata.json')));
+  const bundle = metadata?.fileMetadata?.ios?.bundle;
+  if (typeof bundle !== 'string' || path.isAbsolute(bundle) || bundle.split(/[\\/]/).includes('..')) throw Error('export metadata has no in-tree iOS bundle');
+  const marker = { generation: randomUUID(), exportHash: sha256(fs.readFileSync(path.join(root, bundle))),
+    mode: skip ? 'skipped' : 'background', reason: skip, publishedAt: Date.now() };
+  fs.writeFileSync(path.join(root, publicationMarker), JSON.stringify(marker));
+}
+
 export function skipReason(platform, env) {
   if (env.SNAPBACK4_NATIVE_SMOKE === 'off') return 'SNAPBACK4_NATIVE_SMOKE=off';
   if (platform !== 'darwin') return 'macOS is required';
@@ -80,50 +92,59 @@ export function retainEvidence(root, completed, binary = 'snapback4') {
 // The helper locks a duplicate of this descriptor, so the kernel lease stays
 // with this process after the helper exits. Children do not inherit it unless
 // explicitly listed in stdio (the publisher must keep it if this wrapper dies).
-export function acquireExportLease(artifacts, binary = 'snapback4') {
-  const fd = fs.openSync(path.join(artifacts, 'export.lock'), 'a+');
-  const result = spawnSync(binary, ['witness', 'export-lease', artifacts], { encoding: 'utf8', env: { ...process.env, SNAPBACK4_EXPORT_WRAPPER_PID: String(process.pid) }, stdio: ['ignore', 'pipe', 'pipe', fd] });
+export function acquireExportLease(artifacts, binary = 'snapback4', initialize = false) {
+  const fd = fs.openSync(path.join(artifacts, initialize ? 'initialization.lock' : 'export.lock'), 'a+');
+  const result = spawnSync(binary, ['witness', 'export-lease', artifacts, ...(initialize ? ['--initialize'] : [])], { encoding: 'utf8', env: { ...process.env, SNAPBACK4_EXPORT_WRAPPER_PID: String(process.pid) }, stdio: ['ignore', 'pipe', 'pipe', fd] });
   if (result.status !== 0) { fs.closeSync(fd); throw Error(result.stderr || result.error?.message || 'export lease failed'); }
   return fd;
 }
 export async function main() {
   const req = createRequire(path.resolve('package.json'));
+  // Status is informational: neither an earlier failed proof nor its reporter
+  // can fail a new export. The detached worker owns maintenance and cleanup.
+  spawnSync('snapback4', ['witness', 'status', '--if-present'], { stdio: 'inherit', timeout: 5000 });
   const skip = skipReason(process.platform, process.env);
-  if (skip) {
-    const exported = await runChild(process.execPath, [req.resolve('expo/bin/cli'), 'export', '--platform', 'ios', '--dump-assetmap']);
-    if (exported.status !== 0) return exported.status;
-    console.log(`native smoke skipped: ${skip}`); return 0;
-  }
   const root = path.resolve('artifacts/native-smoke');
   const artifacts = path.join(root, `${Date.now()}-${process.pid}`);
   const privateExport = path.join(artifacts, 'export');
-  const receiptPath = path.join(artifacts, 'smoke-ios-run.json');
-  fs.mkdirSync(artifacts, { recursive: true });
-  const lease = acquireExportLease(artifacts);
-  let publicationAttempted = false;
+  const publicationExport = path.join(artifacts, 'publication-export');
+  let lease, initialization, created = false, publicationAttempted = false;
   try {
+    fs.mkdirSync(root, { recursive: true });
+    const maintenance = spawnSync('snapback4', ['witness', 'export-maintenance', root], { stdio: 'inherit', timeout: 5000 });
+    if (maintenance.status !== 0) console.error('native smoke evidence cleanup deferred; the next export will retry maintenance');
+    initialization = acquireExportLease(root, 'snapback4', true);
+    fs.mkdirSync(artifacts); created = true;
+    lease = acquireExportLease(artifacts);
+    fs.closeSync(initialization); initialization = undefined;
     const exported = await runChild(process.execPath, [req.resolve('expo/bin/cli'), 'export', '--platform', 'ios', '--dump-assetmap', '--output-dir', privateExport]);
     if (exported.status !== 0) return exported.status;
-    const result = await runChild('snapback4', ['witness', 'ios', '--build', '.', '--smoke', '--export', privateExport, '--artifacts', artifacts], { env: { ...process.env, SNAPBACK4_EXPORT_WRAPPER_PID: String(process.pid) } });
-    let receipt;
-    try { receipt = JSON.parse(fs.readFileSync(receiptPath, 'utf8')); } catch {}
-    const outcome = result.cancelled ? { status: result.status, message: 'native smoke interrupted' } : smokeResult(result.status, receipt);
-    if (outcome.status === 0) {
-      const expected = publicationExpectation(artifacts, privateExport, result.status !== 0, receipt);
-      publicationAttempted = true;
-      const published = await runChild('snapback4', ['witness', 'export-publish', privateExport, path.resolve('dist'), ...(result.status === 0 ? [] : ['--environment-skip'])], { stdio: ['inherit', 'inherit', 'inherit', lease] });
-      try {
-        verifyPublication(artifacts, privateExport, path.resolve('dist'), expected);
-        if (published.status !== 0) throw Error(`publisher exited with status ${published.status}`);
-      } catch (error) { outcome.status = published.status || 1; outcome.message = `export output publication failed: ${error.message}`; }
+    markPublication(privateExport, skip);
+    const expected = publicationExpectation(artifacts, privateExport, true);
+    // APFS clones avoid copying bundle bytes. Both trees are independently
+    // verified by the publisher; replacing dist cannot mutate the smoke input.
+    fs.cpSync(privateExport, publicationExport, { recursive: true, mode: fs.constants.COPYFILE_FICLONE });
+    publicationAttempted = true;
+    const published = await runChild('snapback4', ['witness', 'export-publish', publicationExport, path.resolve('dist'), skip ? '--environment-skip' : '--background'], { stdio: ['inherit', 'inherit', 'inherit', lease] });
+    try {
+      verifyPublication(artifacts, publicationExport, path.resolve('dist'), expected);
+      if (published.status !== 0) throw Error(`publisher exited with status ${published.status}`);
+    } catch (error) {
+      console.log(`export output publication failed: ${error.message}`);
+      return published.status || 1;
     }
-    console.log(`${outcome.message}; receipt: ${receiptPath}`);
-    return outcome.status;
+    if (skip) console.log(`native smoke skipped: ${skip}`);
+    return 0;
   } finally {
     // After a publication attempt this path may be the displaced last good
     // export. Only the publisher, under its destination lock, may remove it.
-    try { if (!publicationAttempted) fs.rmSync(privateExport, { recursive: true, force: true }); }
-    finally { fs.closeSync(lease); retainEvidence(root, artifacts); }
+    try { if (created && !publicationAttempted) fs.rmSync(artifacts, { recursive: true, force: true }); }
+    finally {
+      try {
+        if (lease !== undefined) fs.closeSync(lease);
+        else if (created) fs.rmSync(artifacts, { recursive: true, force: true });
+      } finally { if (initialization !== undefined) fs.closeSync(initialization); }
+    }
   }
 }
 if (process.argv[1] && import.meta.url === pathToFileURL(fs.realpathSync(process.argv[1])).href) {

package/ios/Snapback4Device.xcframework/Info.plist

@@ -10,7 +10,7 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>libsnapback4_device.a</string>
 			<key>SupportedArchitectures</key>
@@ -19,8 +19,6 @@
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
@@ -28,7 +26,7 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64-simulator</string>
 			<key>LibraryPath</key>
 			<string>libsnapback4_device.a</string>
 			<key>SupportedArchitectures</key>
@@ -37,6 +35,8 @@
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snapback4-expo",
-  "version": "0.4.12",
+  "version": "0.4.14",
   "type": "module",
   "description": "Snapback 4's native module for Expo: the device in Rust (the partition in its own SQLite, the stream applied, the outbox kept, queries and predictions answered) behind one JSON call, and the opener `snapback4/native` takes.",
   "main": "src/index.ts",