Sync VCC Plus 3.7.1 build 67 source

Refresh reviewed MCP output export, four-drive owned playtests, bounded BASIC readiness, and pinned CMOC 0.1.101 source/patches. Preserve independent source-edition identity, empty libraries, notices and privacy boundaries.

Validated 74 export/privacy checks, pinned dependency sources, and an independent unsigned universal Release build. A subsequent documentation-only correction removes an excluded qualification link; all build inputs remain identical.
This commit is contained in:
Brian Holman committed 2026-11-17 08:42:27 -07:00
1 parent 4abc194001
commit 5534005799
54 files changed
+2950 -435

No files matched your search

@@ -1829,6 +1829,469 @@ final class MCPPlaytestTests: XCTestCase {
catch { XCTAssertTrue(error.localizedDescription.contains("stale_run")) }
}
func testOwnedMultipleDrivesReadBothWriteOnlyHomeAndRetainIndependentlyOnBothProcessors() async throws {
let (helper, system, diskROM) = try inputs()
for cpu in ["6809", "6309"] {
for homeDrive in 0...2 {
let dataDrive = homeDrive + 1
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCMultiDrive-" + UUID().uuidString)
defer { try? FileManager.default.removeItem(at: root) }
var home = disk(), data = disk()
home.replaceSubrange(0..<4, with: Data("HOME".utf8))
data.replaceSubrange(0..<4, with: Data("DATA".utf8))
let declaration = declaredMedia(artifact: UUID().uuidString, project: "multi-drive-\(cpu)-\(homeDrive)", primary: home, world: data)
// DSKI$ returns two 128-byte strings per sector. Reserve a
// normal BASIC string heap for both disks and the save buffers.
let source = "CLEAR2000\n5 H=\(homeDrive):D=\(dataDrive)\n10 IFINKEY$=\"\"THEN10\n20 DSKI$H,0,1,A$,B$:DSKI$D,0,1,C$,E$:PRINTLEFT$(A$,4);\":\";LEFT$(C$,4)\n30 A$=\"SAVE\"+STRING$(124,88):B$=STRING$(128,89):DSKO$H,0,2,A$,B$:DSKI$H,0,2,A$,B$:PRINTLEFT$(A$,4):GOTO10\nRUN\n"
let test = try await MCPPlaytest.start(systemROM: system, diskROM: diskROM, disk: home,
bootCommands: source, projectID: "multi-drive-\(cpu)-\(homeDrive)", revision: 1,
artifactID: declaration.proof.artifactID!, cpu: cpu, helperURL: helper,
retentionDirectory: root, diskProvenance: declaration.proof, media: declaration.media, multiDrive: true)
defer { test.invalidate() }
_ = try await test.pausePlaytest()
func exchange(_ drive: Int, _ id: String?, _ hash: String?, _ requestID: String, protection: Bool? = nil) async throws -> [String: Any] {
var request: [String: Any] = ["run_id": test.runID, "request_id": requestID, "action": id == nil ? "eject" : "insert", "drive": drive]
if let id { request["media_id"] = id; request["media_sha256"] = hash }
if let protection { request["write_protected"] = protection }
return try await test.reply("exchange_playtest_media", arguments: request)
}
let before = try await test.capture()
XCTAssertEqual((before["drives"] as? [[String: Any]])?.count, 4)
for invalid: Any in [true, 1.5, -1, 4, "1"] {
await expectDiskFailure {
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id": test.runID, "request_id": "invalid-drive", "action": "eject", "drive": invalid])
}
}
for invalid: Any in [1, "true"] {
await expectDiskFailure {
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id": test.runID, "request_id": "invalid-protection", "action": "insert", "drive": dataDrive,
"media_id": declaration.media[1].id, "media_sha256": declaration.media[1].baseSHA256, "write_protected": invalid])
}
}
await expectDiskFailure {
_ = try await exchange(dataDrive, declaration.media[0].id, declaration.media[0].baseSHA256, "duplicate-mount")
}
if homeDrive != 0 {
_ = try await exchange(0, nil, nil, "eject-home")
_ = try await exchange(homeDrive, declaration.media[0].id, declaration.media[0].baseSHA256, "move-home")
}
let inserted = try await exchange(dataDrive, declaration.media[1].id, declaration.media[1].baseSHA256, "data", protection: true)
let insertedRows = try XCTUnwrap(inserted["drives"] as? [[String: Any]])
XCTAssertEqual(insertedRows[dataDrive]["write_protected"] as? Bool, true)
XCTAssertEqual(insertedRows[homeDrive]["write_protected"] as? Bool, false)
XCTAssertEqual(inserted["field_clock"] as? Int, before["field_clock"] as? Int)
XCTAssertEqual(inserted["target_drive"] as? Int, dataDrive)
XCTAssertEqual(inserted["media_id"] as? String, homeDrive == 0 ? declaration.media[0].id : nil)
let retry = try await exchange(dataDrive, declaration.media[1].id, declaration.media[1].baseSHA256, "data", protection: true)
XCTAssertEqual(inserted as NSDictionary, retry as NSDictionary)
await expectDiskFailure { _ = try await exchange(homeDrive, declaration.media[1].id, declaration.media[1].baseSHA256, "data", protection: true) }
await expectDiskFailure { _ = try await exchange(dataDrive, declaration.media[1].id, declaration.media[1].baseSHA256, "data", protection: false) }
_ = try await test.continuePlaytest()
_ = try await test.reply("playtest_input", arguments: ["run_id": test.runID, "request_id": "read-and-save", "steps": [["keys": ["r"], "fields": 18], ["keys": [], "fields": 420]]])
_ = try await test.pausePlaytest()
let saved = try await test.capture()
let text = saved["screen_text"] as? String ?? ""
XCTAssertTrue(text.contains("HOME:DATA"), text)
XCTAssertTrue(text.contains("SAVE"), text)
let rows = try XCTUnwrap(saved["drives"] as? [[String: Any]])
XCTAssertGreaterThan((rows[homeDrive]["disk_reads"] as? Int) ?? 0, 0)
XCTAssertGreaterThan((rows[homeDrive]["disk_writes"] as? Int) ?? 0, 0)
XCTAssertGreaterThan((rows[dataDrive]["disk_reads"] as? Int) ?? 0, 0)
XCTAssertEqual(rows[dataDrive]["disk_writes"] as? Int, 0)
XCTAssertEqual(rows[dataDrive]["disk_sha256"] as? String, CMOCProject.sha256(data))
XCTAssertNotEqual(rows[homeDrive]["disk_sha256"] as? String, CMOCProject.sha256(home))
let restarted = try await test.reply("restart_playtest", arguments: ["run_id": test.runID, "request_id": "restart-all"])
let restartedRows = try XCTUnwrap(restarted["drives"] as? [[String: Any]])
for drive in 0..<4 {
XCTAssertEqual(restartedRows[drive]["media_id"] as? String, rows[drive]["media_id"] as? String)
XCTAssertEqual(restartedRows[drive]["disk_sha256"] as? String, rows[drive]["disk_sha256"] as? String)
XCTAssertEqual(restartedRows[drive]["write_protected"] as? Bool, rows[drive]["write_protected"] as? Bool)
}
let stopArgs: [String: Any] = ["run_id": test.runID, "request_id": "stop"]
let stopped = try await test.reply("stop_playtest", arguments: stopArgs)
let repeated = try await test.reply("stop_playtest", arguments: stopArgs)
XCTAssertEqual(stopped as NSDictionary, repeated as NSDictionary)
let retained = try XCTUnwrap(stopped["retained_media"] as? [[String: Any]])
XCTAssertEqual(retained.count, 2)
XCTAssertEqual(Set(retained.compactMap { $0["retained_disk_id"] as? String }).count, 2)
for (index, medium) in declaration.media.enumerated() {
let record = try XCTUnwrap(retained.first { $0["media_id"] as? String == medium.id })
let id = try XCTUnwrap(record["retained_disk_id"] as? String), hash = try XCTUnwrap(record["disk_sha256"] as? String)
let loaded = try await MCPPlaytestDiskStore.load(directory: root, id: id, expectedSHA256: hash,
projectKey: declaration.key, artifactDiskSHA256: declaration.proof.artifactDiskSHA256!,
mediaKey: medium.key, mediaBaseSHA256: medium.baseSHA256)
XCTAssertEqual(loaded.record.provenance.writeProtected, index == 1)
if index == 1 { XCTAssertEqual(loaded.data, data) }
else { XCTAssertEqual(String(decoding: loaded.data[256..<260], as: UTF8.self), "SAVE") }
}
}
}
}
func testMultiDriveDefaultFD0RetryIdentityAndIndependentEqualByteCopies() async throws {
let (helper, system, diskROM) = try inputs()
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCMultiIdentity-" + UUID().uuidString)
defer { try? FileManager.default.removeItem(at: root) }
let original = disk(), declaration = declaredMedia(artifact: UUID().uuidString, project: "multi-identity", primary: original, world: original)
let test = try await MCPPlaytest.start(systemROM: system, diskROM: diskROM, disk: original,
bootCommands: "10 GOTO10\nRUN\n", projectID: "multi-identity", revision: 1,
artifactID: declaration.proof.artifactID!, helperURL: helper, retentionDirectory: root,
diskProvenance: declaration.proof, media: declaration.media, multiDrive: true)
defer { test.invalidate() }
_ = try await test.pausePlaytest()
let omitted: [String: Any] = ["run_id": test.runID, "request_id": "default-eject", "action": "eject"]
let ejected = try await test.reply("exchange_playtest_media", arguments: omitted)
var explicit = omitted; explicit["drive"] = 0
let explicitRetry = try await test.reply("exchange_playtest_media", arguments: explicit)
XCTAssertEqual(explicitRetry as NSDictionary, ejected as NSDictionary)
for drive in 0...1 {
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id": test.runID, "request_id": "insert-\(drive)", "action": "insert", "drive": drive,
"media_id": declaration.media[drive].id, "media_sha256": declaration.media[drive].baseSHA256])
}
let snapshot = try await test.capture()
let rows = try XCTUnwrap(snapshot["drives"] as? [[String: Any]])
XCTAssertNotEqual(rows[0]["media_id"] as? String, rows[1]["media_id"] as? String)
XCTAssertEqual(rows[0]["disk_sha256"] as? String, rows[1]["disk_sha256"] as? String)
let stopped = try await test.reply("stop_playtest", arguments: ["run_id": test.runID, "request_id": "stop"])
XCTAssertEqual((stopped["retained_media"] as? [[String: Any]])?.count, 2)
}
func testMultiDriveStopDrainsFourLargeDisksWithinTheExistingWireLimit() async throws {
let (helper, system, diskROM) = try inputs()
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCFourDriveDrain-" + UUID().uuidString)
defer { try? FileManager.default.removeItem(at: root) }
let artifact = UUID().uuidString, project = "four-drive-drain", projectKey = CMOCProject.sha256(Data(project.utf8))
let base = disk(), primaryHash = CMOCProject.sha256(base)
let media = (0..<4).map { index -> MCPPlaytestMedium in
// 80-track single-sided raw images are valid and fit the per-image
// budget. Four base64 payloads would exceed the 1 MiB wire bound.
var bytes = index == 0 ? base : Data(repeating: UInt8(40 + index), count: 80 * 18 * 256)
bytes[0] = UInt8(index)
let key = index == 0 ? "primary" : "disk:drive\(index).dsk", hash = CMOCProject.sha256(bytes)
let proof = MCPPlaytestDiskStore.Provenance(projectKey: projectKey, artifactID: artifact,
artifactDiskSHA256: primaryHash, mediaKey: key, mediaBaseSHA256: hash)
return MCPPlaytestMedium(id: MCPPlaytestMedium.identifier(artifactID: artifact, key: key), name: "drive\(index).dsk",
key: key, baseSHA256: hash, data: bytes, provenance: proof)
}
// Keep primary hash and actual bytes identical for artifact binding.
let primary = media[0]
let test = try await MCPPlaytest.start(systemROM: system, diskROM: diskROM, disk: primary.data,
bootCommands: "10 GOTO10\nRUN\n", projectID: project, revision: 1, artifactID: artifact,
helperURL: helper, retentionDirectory: root, diskProvenance: primary.provenance, media: media, multiDrive: true)
defer { test.invalidate() }
_ = try await test.pausePlaytest()
for drive in 1...3 {
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id": test.runID, "request_id": "drive-\(drive)", "action": "insert", "drive": drive,
"media_id": media[drive].id, "media_sha256": media[drive].baseSHA256])
}
let stopped = try await test.reply("stop_playtest", arguments: ["run_id": test.runID, "request_id": "stop"])
let records = try XCTUnwrap(stopped["retained_media"] as? [[String: Any]])
XCTAssertEqual(records.count, 4)
for medium in media {
let record = try XCTUnwrap(records.first { $0["media_id"] as? String == medium.id })
XCTAssertEqual(record["disk_sha256"] as? String, medium.baseSHA256)
let id = try XCTUnwrap(record["retained_disk_id"] as? String)
XCTAssertEqual(try Data(contentsOf: MCPPlaytestDiskStore.diskURL(directory: root, id: id)), medium.data)
}
}
func testMultiDriveRetentionCanRetryAfterFrozenWorkerExit() async throws {
let (helper, system, diskROM) = try inputs()
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCMultiRetentionRetry-" + UUID().uuidString)
try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true, attributes: [.posixPermissions: 0o700])
defer { try? FileManager.default.removeItem(at: root) }
let blocked = root.appendingPathComponent("retained")
try Data("not a folder".utf8).write(to: blocked)
let original = disk(); var data = disk(); data[0] = 81
let declaration = declaredMedia(artifact: UUID().uuidString, project: "multi-retention-retry", primary: original, world: data)
let test = try await MCPPlaytest.start(systemROM: system, diskROM: diskROM, disk: original,
bootCommands: "10 PRINT 47\nSAVE\"HOME\"\n", projectID: "multi-retention-retry", revision: 1,
artifactID: declaration.proof.artifactID!, helperURL: helper, retentionDirectory: blocked,
diskProvenance: declaration.proof, media: declaration.media, multiDrive: true)
defer { test.invalidate() }
_ = try await test.pausePlaytest()
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id": test.runID, "request_id": "data", "action": "insert", "drive": 1,
"media_id": declaration.media[1].id, "media_sha256": declaration.media[1].baseSHA256])
let before = try await test.capture()
let beforeRows = try XCTUnwrap(before["drives"] as? [[String: Any]])
let stop: [String: Any] = ["run_id": test.runID, "request_id": "stop"]
await expectDiskFailure { _ = try await test.reply("stop_playtest", arguments: stop) }
XCTAssertNotNil(test.retentionError)
let pending = try await test.capture()
XCTAssertEqual(pending["status"] as? String, "retention_pending")
try FileManager.default.removeItem(at: blocked)
let stopped = try await test.reply("stop_playtest", arguments: stop)
XCTAssertNil(test.retentionError)
let records = try XCTUnwrap(stopped["retained_media"] as? [[String: Any]])
XCTAssertEqual(records.count, 2)
for index in 0...1 {
let record = try XCTUnwrap(records.first { $0["media_id"] as? String == declaration.media[index].id })
XCTAssertEqual(record["disk_sha256"] as? String, beforeRows[index]["disk_sha256"] as? String)
}
}
func testOwnedDriveProtectionBlocksGuestWriteAndCanBeChangedWithReview() async throws {
let (helper, system, diskROM) = try inputs()
for cpu in ["6809", "6309"] {
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCOwnedWriteProtect-" + UUID().uuidString)
defer { try? FileManager.default.removeItem(at: root) }
let original = disk(), declaration = declaredMedia(artifact: UUID().uuidString, project: "protected-" + cpu, primary: original, world: original)
let program = "CLEAR2000\n10 IFINKEY$=\"\"THEN10\n20 A$=STRING$(128,88):B$=STRING$(128,89):DSKO$0,0,2,A$,B$:PRINT\"WROTE HOME\":GOTO10\nRUN\n"
let test = try await MCPPlaytest.start(systemROM: system, diskROM: diskROM, disk: original,
bootCommands: program, projectID: "protected-" + cpu, revision: 1, artifactID: declaration.proof.artifactID!, cpu: cpu,
helperURL: helper, retentionDirectory: root, diskProvenance: declaration.proof, media: declaration.media, multiDrive: true)
defer { test.invalidate() }
_ = try await test.pausePlaytest()
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id": test.runID, "request_id": "protect", "action": "insert",
"media_id": declaration.media[0].id, "media_sha256": declaration.media[0].baseSHA256, "write_protected": true])
_ = try await test.continuePlaytest()
_ = try await test.reply("playtest_input", arguments: ["run_id": test.runID, "request_id": "protected-write",
"steps": [["keys": ["r"], "fields": 18], ["keys": [], "fields": 180]]])
_ = try await test.pausePlaytest()
let refused = try await test.capture()
let rows = try XCTUnwrap(refused["drives"] as? [[String: Any]])
XCTAssertEqual(rows[0]["disk_sha256"] as? String, declaration.media[0].baseSHA256)
XCTAssertEqual(rows[0]["disk_writes"] as? Int, 0)
XCTAssertTrue((refused["screen_text"] as? String ?? "").contains("WP ERROR"), refused["screen_text"] as? String ?? "")
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id": test.runID, "request_id": "unprotect", "action": "insert", "drive": 0,
"media_id": declaration.media[0].id, "media_sha256": declaration.media[0].baseSHA256, "write_protected": false])
_ = try await test.reply("restart_playtest", arguments: ["run_id": test.runID, "request_id": "restart"])
_ = try await test.reply("playtest_input", arguments: ["run_id": test.runID, "request_id": "writable-write",
"steps": [["keys": ["r"], "fields": 18], ["keys": [], "fields": 240]]])
_ = try await test.pausePlaytest()
let written = try await test.capture()
let writtenRows = try XCTUnwrap(written["drives"] as? [[String: Any]])
XCTAssertGreaterThan(writtenRows[0]["disk_writes"] as? Int ?? 0, 0)
XCTAssertNotEqual(writtenRows[0]["disk_sha256"] as? String, declaration.media[0].baseSHA256)
XCTAssertTrue((written["screen_text"] as? String ?? "").contains("WROTE HOME"))
_ = try await test.reply("stop_playtest", arguments: ["run_id": test.runID, "request_id": "stop"])
}
}
func testMultiDriveExchangeChecksSharedControllerAndMalformedDriveBeforeMutation() async throws {
let (helper, system, diskROM) = try inputs()
for cpu in ["6809", "6309"] {
let worker = try MediaWorkerClient(helper); defer { worker.close() }
// Real guest selects FD0 and starts a read with motor disabled;
// even an otherwise empty FD3 must refuse its own exchange.
let commands = try CocoPaste("POKE65344,1:POKE65352,128\n", mode: .text)
_ = try await worker.request(["op": "init", "system_rom": system.base64EncodedString(), "disk_rom": diskROM.base64EncodedString(),
"disk": disk().base64EncodedString(), "boot_keys": commands.chords.map { NSNumber(value: $0) }, "cpu": cpu, "multi_drive": true])
_ = try await worker.request(["op": "pause"])
let before = try await worker.request(["op": "media_status"])
XCTAssertEqual(before["floppy_busy"] as? Bool, true)
for drive: Any in [true, 1.25, -1, 4] {
await expectDiskFailure {
_ = try await worker.request(["op": "exchange_media", "drive": drive, "expected_media_generation": 0, "expected_disk_sha256": ""])
}
}
do {
_ = try await worker.request(["op": "exchange_media", "drive": 3, "expected_media_generation": 0, "expected_disk_sha256": ""])
XCTFail("A pending FD0 command must block FD3 replacement")
} catch { XCTAssertTrue(error.localizedDescription.contains("playtest_media_busy")) }
let after = try await worker.request(["op": "media_status"])
XCTAssertEqual(before["drives"] as? NSArray, after["drives"] as? NSArray)
for key in ["field_clock", "cycles", "generation", "pc", "boot"] { XCTAssertEqual(before[key] as? NSNumber, after[key] as? NSNumber) }
let frozen = try await worker.request(["op": "stop"])
XCTAssertEqual(frozen["media_frozen"] as? Bool, true)
for drive in 0..<4 { _ = try await worker.request(["op": "export_media", "drive": drive]) }
_ = try await worker.request(["op": "finish_stop"])
}
}
/// These are bounded negative protocol fixtures, not emulator evidence.
/// Actual guest I/O is covered by the independent both-CPU tests above.
private func faultingMultiDriveHelper(_ mode: String, root: URL) throws -> URL {
try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true, attributes: [.posixPermissions: 0o700])
let path = root.appendingPathComponent("multi-wire-fixture")
let source = """
#!/usr/bin/env python3
import sys,json,base64,hashlib,os
mode=\(String(reflecting: mode))
disks=[None]*4; ids=[None]*4; gens=[0]*4; protections=[False]*4; originals=['']*4
cpu='6809'; frozen=False; failed_export=False
def digest(data): return hashlib.sha256(data).hexdigest() if data else ''
def row(drive):
data=disks[drive]
return {'drive':drive,'label':'FD'+str(drive),'inserted':data is not None,'disk_present':data is not None,
'media_id':ids[drive],'disk_original_sha256':originals[drive],'disk_sha256':digest(data),
'media_generation':gens[drive],'byte_count':len(data) if data else 0,'disk_dirty':False,
'write_protected':protections[drive],'disk_reads':0,'disk_writes':0,'mount_read_bytes':0,'mount_write_bytes':0}
def status():
first=row(0)
return {'cpu':cpu,'processor':'HD6309' if cpu=='6309' else 'MC6809','state':'paused',
'media_id':first['media_id'],'disk_present':first['disk_present'],'disk_sha256':first['disk_sha256'],
'disk_original_sha256':first['disk_original_sha256'],'media_generation':gens[0],
'disk_dirty':False,'floppy_busy':False,'field_clock':0,'cycles':100,'generation':1,'boot':1,'pc':100,
'drives':[row(d) for d in range(4)]}
for line in sys.stdin:
r=json.loads(line); op=r['op']; end=False
with open(os.path.join(os.path.dirname(__file__),'trace.jsonl'),'a') as trace: trace.write(json.dumps(r)+'\\n')
if op=='init':
disks[0]=base64.b64decode(r['disk']); ids[0]=r['media_id']; cpu=r['cpu']; originals[0]=digest(disks[0]); out=status()
elif op=='export_media':
drive=r['drive']
if mode=='partial-stop' and frozen and drive==2 and not os.path.exists(os.path.join(os.path.dirname(__file__),'retry')):
print(json.dumps({'error':'fixture_partial_drain'}),flush=True); continue
out=status(); out['exported_drive']=row(drive)
if disks[drive] is not None: out['disk_base64']=base64.b64encode(disks[drive]).decode()
if mode=='wrong-target' and not frozen and drive==1 and not failed_export:
out['exported_drive']['media_id']='foreign'; failed_export=True
elif op in ('media_status','capture','pause'): out=status()
elif op=='exchange_media':
drive=r['drive']; old=digest(disks[drive]); ids[drive]=r.get('media_id')
disks[drive]=base64.b64decode(r['disk_base64']) if ids[drive] else None
protections[drive]=r.get('write_protected',False); originals[drive]=digest(disks[drive]); gens[drive]+=1
if mode=='exit-after-commit': os._exit(0)
if mode=='mark-after-commit':
with open(os.path.join(os.path.dirname(__file__),'committed'),'w') as marker: marker.write('committed')
out=status(); out['previous_disk_sha256']=old; out['target_drive']=drive
elif op=='stop':
frozen=True; out=status(); out['media_frozen']=True
elif op=='finish_stop': out=status(); end=True
else:
print(json.dumps({'error':'unexpected_operation'}),flush=True); continue
print(json.dumps({'result':out}),flush=True)
if end: break
"""
try Data(source.utf8).write(to: path)
try FileManager.default.setAttributes([.posixPermissions: 0o700], ofItemAtPath: path.path)
return path
}
func testMultiDriveLostCommitRetainsAllFrozenCopiesAndMarksOnlyTargetUncertain() async throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCMultiLostReply-" + UUID().uuidString)
defer { try? FileManager.default.removeItem(at: root) }
let helper = try faultingMultiDriveHelper("exit-after-commit", root: root)
let original = disk(); var data = disk(); data[0] = 93
let declaration = declaredMedia(artifact: UUID().uuidString, project: "multi-lost", primary: original, world: data)
let test = try await MCPPlaytest.start(systemROM: Data(repeating: 0, count: 32768), diskROM: Data(repeating: 0, count: 8192), disk: original,
bootCommands: "PRINT1\n", projectID: "multi-lost", revision: 1, artifactID: declaration.proof.artifactID!, helperURL: helper,
retentionDirectory: root.appendingPathComponent("retained"), diskProvenance: declaration.proof, media: declaration.media, multiDrive: true)
await expectDiskFailure {
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id": test.runID,"request_id":"lost","action":"insert","drive":1,
"media_id":declaration.media[1].id,"media_sha256":declaration.media[1].baseSHA256])
}
await test.invalidate().value
let receipt = try XCTUnwrap(test.finalReceipt)
XCTAssertEqual(receipt["media_selection_uncertain"] as? Bool, true)
XCTAssertEqual(receipt["uncertain_drives"] as? [Int], [1])
let drives = try XCTUnwrap(receipt["drives"] as? [[String: Any]])
XCTAssertEqual(drives[0]["media_id"] as? String, declaration.media[0].id)
XCTAssertTrue(drives[1]["media_id"] is NSNull)
let retained = try XCTUnwrap(receipt["retained_media"] as? [[String: Any]])
XCTAssertEqual(retained.count, 2)
for medium in declaration.media {
let row = try XCTUnwrap(retained.first { $0["media_id"] as? String == medium.id })
XCTAssertEqual(row["disk_sha256"] as? String, medium.baseSHA256)
}
}
func testMultiDrivePartialDrainRetriesWithoutASecondStopOrRepeatedEarlierExport() async throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCMultiPartialDrain-" + UUID().uuidString)
defer { try? FileManager.default.removeItem(at: root) }
let helper = try faultingMultiDriveHelper("partial-stop", root: root)
let original = disk(), declaration = declaredMedia(artifact: UUID().uuidString, project: "multi-partial", primary: original, world: original)
let test = try await MCPPlaytest.start(systemROM: Data(repeating: 0, count: 32768), diskROM: Data(repeating: 0, count: 8192), disk: original,
bootCommands: "PRINT1\n", projectID: "multi-partial", revision: 1, artifactID: declaration.proof.artifactID!, helperURL: helper,
retentionDirectory: root.appendingPathComponent("retained"), diskProvenance: declaration.proof, media: declaration.media, multiDrive: true)
defer { test.invalidate() }
let stop: [String: Any] = ["run_id":test.runID,"request_id":"stop"]
await expectDiskFailure { _ = try await test.reply("stop_playtest", arguments: stop) }
XCTAssertNotNil(test.retentionError)
try Data("retry".utf8).write(to: root.appendingPathComponent("retry"))
let stopped = try await test.reply("stop_playtest", arguments: stop)
XCTAssertEqual(stopped["disk_retained"] as? Bool, true)
let trace = try String(contentsOf: root.appendingPathComponent("trace.jsonl"), encoding: .utf8).split(separator:"\n").map {
try XCTUnwrap(JSONSerialization.jsonObject(with: Data($0.utf8)) as? [String: Any])
}
XCTAssertEqual(trace.filter { $0["op"] as? String == "stop" }.count, 1)
for drive in 0...1 { XCTAssertEqual(trace.filter { $0["op"] as? String == "export_media" && $0["drive"] as? Int == drive }.count, 1) }
XCTAssertEqual(trace.filter { $0["op"] as? String == "export_media" && $0["drive"] as? Int == 2 }.count, 2)
}
func testMultiDriveWrongExportTargetCannotPoisonAnotherMedium() async throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCMultiWrongExport-" + UUID().uuidString)
defer { try? FileManager.default.removeItem(at: root) }
let helper = try faultingMultiDriveHelper("wrong-target", root: root)
let original = disk(); var data = disk(); data[0] = 95
let declaration = declaredMedia(artifact: UUID().uuidString, project: "multi-wrong", primary: original, world: data)
let store = root.appendingPathComponent("retained")
let test = try await MCPPlaytest.start(systemROM: Data(repeating: 0, count: 32768), diskROM: Data(repeating: 0, count: 8192), disk: original,
bootCommands: "PRINT1\n", projectID: "multi-wrong", revision: 1, artifactID: declaration.proof.artifactID!, helperURL: helper,
retentionDirectory: store, diskProvenance: declaration.proof, media: declaration.media, multiDrive: true)
defer { test.invalidate() }
await expectDiskFailure {
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id":test.runID,"request_id":"wrong","action":"insert","drive":1,
"media_id":declaration.media[1].id,"media_sha256":declaration.media[1].baseSHA256])
}
let stopped = try await test.reply("stop_playtest", arguments: ["run_id":test.runID,"request_id":"stop"])
let records = try XCTUnwrap(stopped["retained_media"] as? [[String: Any]])
for medium in declaration.media {
let record = try XCTUnwrap(records.first { $0["media_id"] as? String == medium.id })
let id = try XCTUnwrap(record["retained_disk_id"] as? String)
XCTAssertEqual(try Data(contentsOf: MCPPlaytestDiskStore.diskURL(directory: store,id:id)), medium.data)
}
}
func testMultiDriveRechecksRetainedOutgoingBytesBeforeAnotherReplacement() async throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCMultiRetentionEvidence-" + UUID().uuidString)
defer { try? FileManager.default.removeItem(at: root) }
let helper = try faultingMultiDriveHelper("normal", root: root)
let original = disk(); var data = disk(); data[0] = 97
let declaration = declaredMedia(artifact: UUID().uuidString, project: "multi-retained-evidence", primary: original, world: data)
let store = root.appendingPathComponent("retained")
let test = try await MCPPlaytest.start(systemROM: Data(repeating: 0, count: 32768), diskROM: Data(repeating: 0, count: 8192), disk: original,
bootCommands: "PRINT1\n", projectID: "multi-retained-evidence", revision: 1, artifactID: declaration.proof.artifactID!, helperURL: helper,
retentionDirectory: store, diskProvenance: declaration.proof, media: declaration.media, multiDrive: true)
defer { test.invalidate() }
let eject = try await test.reply("exchange_playtest_media", arguments: ["run_id":test.runID,"request_id":"eject","action":"eject"])
let previous = try XCTUnwrap(eject["previous_media"] as? [String: Any])
let retained = try XCTUnwrap(previous["retained_disk"] as? [String: Any])
let retainedID = try XCTUnwrap(retained["retained_disk_id"] as? String)
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id":test.runID,"request_id":"restore","action":"insert",
"media_id":declaration.media[0].id,"media_sha256":declaration.media[0].baseSHA256])
let url = try MCPPlaytestDiskStore.diskURL(directory: store,id:retainedID)
try data.write(to: url)
await expectDiskFailure {
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id":test.runID,"request_id":"changed-evidence","action":"insert",
"media_id":declaration.media[1].id,"media_sha256":declaration.media[1].baseSHA256])
}
let unchanged = try await test.capture()
XCTAssertEqual(unchanged["media_id"] as? String, declaration.media[0].id)
XCTAssertEqual(unchanged["disk_sha256"] as? String, declaration.media[0].baseSHA256)
XCTAssertEqual(try Data(contentsOf:url), data, "The failed swap must not silently repair changed retention evidence")
try original.write(to:url)
_ = try await test.reply("stop_playtest", arguments:["run_id":test.runID,"request_id":"stop"])
}
func testMultiDriveLateAuthorityLossPreservesAcknowledgedTargetReceipt() async throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCMultiLateAuthority-" + UUID().uuidString)
defer { try? FileManager.default.removeItem(at: root) }
let helper = try faultingMultiDriveHelper("mark-after-commit", root:root)
let original = disk(); var data = disk(); data[0] = 99
let declaration = declaredMedia(artifact: UUID().uuidString, project:"multi-late-authority", primary:original,world:data)
let test = try await MCPPlaytest.start(systemROM:Data(repeating:0,count:32768),diskROM:Data(repeating:0,count:8192),disk:original,
bootCommands:"PRINT1\n",projectID:"multi-late-authority",revision:1,artifactID:declaration.proof.artifactID!,helperURL:helper,
retentionDirectory:root.appendingPathComponent("retained"),diskProvenance:declaration.proof,media:declaration.media,multiDrive:true)
defer { test.invalidate() }
let request: [String:Any] = ["run_id":test.runID,"request_id":"commit","action":"insert","drive":1,"write_protected":true,
"media_id":declaration.media[1].id,"media_sha256":declaration.media[1].baseSHA256]
do {
_ = try await test.reply("exchange_playtest_media",arguments:request,isCurrent:{ !FileManager.default.fileExists(atPath:root.appendingPathComponent("committed").path) })
XCTFail("A committed exchange cannot return through expired authority")
} catch { XCTAssertTrue(error.localizedDescription.contains("stale_run_after_commit")) }
let acknowledged = try await test.reply("exchange_playtest_media",arguments:request)
XCTAssertEqual(acknowledged["target_drive"] as? Int,1)
let rows = try XCTUnwrap(acknowledged["drives"] as? [[String:Any]])
XCTAssertEqual(rows[1]["media_id"] as? String,declaration.media[1].id)
XCTAssertEqual(rows[1]["media_generation"] as? Int,1)
XCTAssertEqual(rows[1]["write_protected"] as? Bool,true)
let stopped = try await test.reply("stop_playtest",arguments:["run_id":test.runID,"request_id":"stop"])
let records = try XCTUnwrap(stopped["retained_media"] as? [[String:Any]])
XCTAssertEqual(records.first { $0["media_id"] as? String == declaration.media[1].id }?["write_protected"] as? Bool,true)
}
private func declaredMedia(artifact: String, project: String, primary: Data, world: Data)
-> (key: String, proof: MCPPlaytestDiskStore.Provenance, media: [MCPPlaytestMedium]) {
let key = CMOCProject.sha256(Data(project.utf8)), primaryHash = CMOCProject.sha256(primary)