@happier-dev/stack 0.2.1-preview.1775586714.26562 → 0.2.12-preview.1

package/scripts/profile_mobile_scenario.mjs

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+import './utils/env/env.mjs';
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import { parseArgs } from './utils/cli/args.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
+import { getRepoDir, getRootDir } from './utils/paths/paths.mjs';
+import {
+  DEFAULT_MOBILE_PROFILE_APP_PROCESS,
+  DEFAULT_MOBILE_PROFILE_FLOW_DIR,
+  DEFAULT_MOBILE_PROFILE_METRO_PORT,
+  DEFAULT_MOBILE_PROFILE_START_DELAY_MS,
+  listMobileProfileScenarios,
+  resolveMobileProfileScenario,
+  resolveMobileProfileTargetPlan,
+  runMobileProfileScenario,
+} from './profiling/mobile_profile_scenarios.mjs';
+import {
+  DEFAULT_CPU_SAMPLE_INTERVAL_MS,
+  DEFAULT_PROFILE_DURATION_MS,
+  DEFAULT_PROFILE_INTERVAL_MS,
+  parseDurationMs,
+  parsePositiveInteger,
+} from './profiling/process_profiler.mjs';
+
+function usage() {
+  return [
+    '[profile-mobile-scenario] usage:',
+    '  hstack tools profile-mobile-scenario --list [--json]',
+    '  hstack tools profile-mobile-scenario --scenario=<name> --udid=<ios-udid> [--metro-port=18829] [--project-root=<repo>] [--flow-dir=.argent/flows] [--json]',
+    '  hstack tools profile-mobile-scenario --scenario=<name> --udid=<ios-udid> --execute-flow [--json]',
+    '  hstack tools profile-mobile-scenario --scenario=<name> --udid=<ios-udid> --execute-flow --profile-process [--pid=<pid>|--command-match=Happierinternaldev] [--duration=30s] [--interval=1s] [--stack-sample=10s] [--out-dir=<dir>] [--json]',
+    '  hstack tools profile-mobile-scenario --scenario=<name> --udid=<ios-udid> --profile-process --dry-run [--json]',
+    '',
+    'Notes:',
+    '  - Generates current-device Argent flow YAML before execution.',
+    '  - Process profiling reuses hstack tools profile-processes logic and reports RSS/CPU facts only.',
+    '  - RSS growth is memory pressure evidence, not an attributed leak.',
+    '  - Native xctrace Allocations/Leaks attribution still requires a dedicated memory-profiling build.',
+  ].join('\n');
+}
+
+function readValue(kv, ...names) {
+  for (const name of names) {
+    if (kv.has(name)) return kv.get(name);
+  }
+  return null;
+}
+
+function textScenarioList(scenarios) {
+  return scenarios.map((scenario) => `- ${scenario.name}: ${scenario.description}`).join('\n');
+}
+
+function textSummary(result) {
+  const lines = [
+    `[profile-mobile-scenario] scenario: ${result.scenario.name}`,
+    `[profile-mobile-scenario] flow: ${result.flow.file}`,
+    `[profile-mobile-scenario] manifest: ${result.artifacts.manifest}`,
+  ];
+  if (result.executed) {
+    lines.push(
+      result.flowResult?.ok
+        ? '[profile-mobile-scenario] flow execution: ok'
+        : `[profile-mobile-scenario] flow execution: failed (${result.flowResult?.exitCode ?? result.flowResult?.signal ?? result.flowResult?.error ?? 'unknown'})`,
+    );
+    if (result.flowValidation) {
+      const failedChecks = result.flowValidation.checks?.filter((check) => !check.ok).length ?? 0;
+      lines.push(
+        result.flowValidation.ok
+          ? `[profile-mobile-scenario] flow checkpoints: ok (${result.flowValidation.checks.length})`
+          : `[profile-mobile-scenario] flow checkpoints: failed (${failedChecks}/${result.flowValidation.checks.length})`,
+      );
+    }
+  } else {
+    lines.push('[profile-mobile-scenario] flow execution: skipped');
+  }
+  if (result.profile) {
+    const cpu = result.profile.summary.cpu;
+    const memory = result.profile.summary.memory;
+    lines.push(
+      `[profile-mobile-scenario] CPU avg ${cpu.averagePercent}% max ${cpu.maxPercent}%`,
+      `[profile-mobile-scenario] RSS start ${memory.rssStartBytes} B, end ${memory.rssEndBytes} B, delta ${memory.rssDeltaBytes} B`,
+      `[profile-mobile-scenario] process summary: ${result.profile.artifacts.summary}`,
+    );
+  }
+  return lines.join('\n');
+}
+
+function dryRunText(plan) {
+  const lines = [
+    `[profile-mobile-scenario] scenario: ${plan.scenario.name}`,
+    `[profile-mobile-scenario] flow file: ${plan.flow.file}`,
+    `[profile-mobile-scenario] execute flow: ${plan.executeFlow ? 'yes' : 'no'}`,
+    `[profile-mobile-scenario] profile process: ${plan.profileProcess ? 'yes' : 'no'}`,
+  ];
+  if (plan.target) {
+    lines.push(`[profile-mobile-scenario] target pid: ${plan.target.pid}`);
+  }
+  lines.push(
+    `[profile-mobile-scenario] duration: ${plan.parameters.durationMs}ms; interval: ${plan.parameters.intervalMs}ms`,
+    plan.parameters.cpuProfileMs
+      ? `[profile-mobile-scenario] cpu sample: ${plan.parameters.cpuProfileMs}ms @ ${plan.parameters.sampleIntervalMs}ms`
+      : '[profile-mobile-scenario] cpu sample: disabled',
+  );
+  return lines.join('\n');
+}
+
+export async function runProfileMobileScenarioCli(argv = process.argv.slice(2), { env = process.env } = {}) {
+  const rootDir = getRootDir(import.meta.url);
+  const { flags, kv } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+
+  if (wantsHelp(argv, { flags })) {
+    printResult({ json, data: { usage: usage() }, text: usage() });
+    return;
+  }
+
+  if (flags.has('--list')) {
+    const scenarios = listMobileProfileScenarios().map((scenario) => ({
+      name: scenario.name,
+      flowName: scenario.flowName,
+      description: scenario.description,
+      prerequisite: scenario.prerequisite,
+    }));
+    printResult({ json, data: { scenarios }, text: textScenarioList(scenarios) });
+    return;
+  }
+
+  const scenarioName = readValue(kv, '--scenario');
+  const scenario = resolveMobileProfileScenario(scenarioName);
+  const udid = readValue(kv, '--udid');
+  if (!udid) {
+    throw new Error('Pass --udid=<ios-udid> to generate or execute a mobile profiling scenario.');
+  }
+
+  const projectRoot = resolve(readValue(kv, '--project-root') ?? getRepoDir(rootDir, env));
+  const flowDir = readValue(kv, '--flow-dir') ?? DEFAULT_MOBILE_PROFILE_FLOW_DIR;
+  const metroPort =
+    readValue(kv, '--metro-port', '--metroPort') == null
+      ? DEFAULT_MOBILE_PROFILE_METRO_PORT
+      : parsePositiveInteger(readValue(kv, '--metro-port', '--metroPort'), 'metro-port');
+  const executeFlow = flags.has('--execute-flow') || flags.has('--execute');
+  const profileProcess = flags.has('--profile-process') || flags.has('--profile');
+  const dryRun = flags.has('--dry-run') || flags.has('--print-plan');
+
+  const durationMs = parseDurationMs(readValue(kv, '--duration', '--duration-ms'), 'duration') ?? DEFAULT_PROFILE_DURATION_MS;
+  const intervalMs = parseDurationMs(readValue(kv, '--interval', '--interval-ms'), 'interval') ?? DEFAULT_PROFILE_INTERVAL_MS;
+  const cpuProfileMs =
+    parseDurationMs(readValue(kv, '--stack-sample', '--stack-sample-ms', '--cpu-profile', '--cpu-profile-ms'), 'stack-sample') ?? 0;
+  const sampleIntervalMs =
+    readValue(kv, '--sample-interval', '--sample-interval-ms') == null
+      ? DEFAULT_CPU_SAMPLE_INTERVAL_MS
+      : parsePositiveInteger(readValue(kv, '--sample-interval', '--sample-interval-ms'), 'sample-interval');
+  const profileStartDelayMs =
+    parseDurationMs(readValue(kv, '--profile-start-delay', '--profile-start-delay-ms'), 'profile-start-delay') ??
+    DEFAULT_MOBILE_PROFILE_START_DELAY_MS;
+  const flowTimeoutMs = parseDurationMs(readValue(kv, '--flow-timeout', '--flow-timeout-ms'), 'flow-timeout') ?? 0;
+  const outputDir = readValue(kv, '--out-dir') ?? join(env.TMPDIR || '/tmp', 'happier-mobile-profile-scenarios');
+  const label = readValue(kv, '--label') ?? scenario.name;
+  const pidRaw = readValue(kv, '--pid');
+  const commandMatch = readValue(kv, '--command-match') ?? DEFAULT_MOBILE_PROFILE_APP_PROCESS;
+  const pid = pidRaw == null ? null : parsePositiveInteger(pidRaw, 'pid');
+  const memoryMap = flags.has('--memory-map');
+  const argentBin = readValue(kv, '--argent-bin') ?? 'argent';
+
+  if (dryRun) {
+    const target = profileProcess ? await resolveMobileProfileTargetPlan({ pid, commandMatch }) : null;
+    const flowFile = resolve(projectRoot, flowDir, `${scenario.flowName}.yaml`);
+    const plan = {
+      scenario: { name: scenario.name, flowName: scenario.flowName, description: scenario.description },
+      projectRoot,
+      flow: { file: flowFile, directory: resolve(projectRoot, flowDir) },
+      executeFlow,
+      profileProcess,
+      target,
+      parameters: {
+        metroPort,
+        durationMs,
+        intervalMs,
+        cpuProfileMs,
+        sampleIntervalMs,
+        profileStartDelayMs,
+        flowTimeoutMs,
+        memoryMap,
+      },
+    };
+    printResult({ json, data: plan, text: dryRunText(plan) });
+    return;
+  }
+
+  const result = await runMobileProfileScenario({
+    projectRoot,
+    scenarioName: scenario.name,
+    udid,
+    metroPort,
+    flowDir,
+    executeFlow,
+    profileProcess,
+    pid,
+    commandMatch,
+    label,
+    outputDir,
+    durationMs,
+    intervalMs,
+    cpuProfileMs,
+    sampleIntervalMs,
+    memoryMap,
+    profileStartDelayMs,
+    argentBin,
+    env,
+    flowTimeoutMs,
+  });
+
+  printResult({ json, data: result, text: textSummary(result) });
+  if (result.executed && result.flowResult && !result.flowResult.ok) {
+    process.exitCode = 1;
+  }
+  if (result.executed && result.flowValidation && !result.flowValidation.ok) {
+    process.exitCode = 1;
+  }
+  if (result.profile?.cpuProfile && !result.profile.cpuProfile.ok) {
+    process.exitCode = 1;
+  }
+  if (result.profile?.memoryMaps && [result.profile.memoryMaps.start, result.profile.memoryMaps.end].some((entry) => entry && !entry.ok)) {
+    process.exitCode = 1;
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  runProfileMobileScenarioCli().catch((err) => {
+    console.error('[profile-mobile-scenario] failed:', err);
+    process.exit(1);
+  });
+}

package/scripts/profile_processes.mjs

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import { parseArgs } from './utils/cli/args.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
+import {
+  DEFAULT_CPU_SAMPLE_INTERVAL_MS,
+  DEFAULT_PROFILE_DURATION_MS,
+  DEFAULT_PROFILE_INTERVAL_MS,
+  parseDurationMs,
+  parsePositiveInteger,
+  resolveProcessTarget,
+  runProcessProfile,
+} from './profiling/process_profiler.mjs';
+
+function usage() {
+  return [
+    '[profile-processes] usage:',
+    '  hstack tools profile-processes --pid=<pid> [--duration=30s] [--interval=1s] [--out-dir=<dir>] [--label=<name>] [--stack-sample=10s] [--memory-map] [--json]',
+    '  hstack tools profile-processes --command-match=<unique substring> [same options]',
+    '  hstack tools profile-processes --pid=<pid> --dry-run [--json]',
+    '',
+    'Notes:',
+    '  - Default output dir is the host temp directory, not the repository.',
+    '  - Memory output is RSS/VSZ sampling plus an optional post-sampling vmmap summary; RSS growth is not reported as a confirmed leak.',
+    '  - CPU stack profiling uses macOS sample only when --stack-sample or --cpu-profile is provided.',
+  ].join('\n');
+}
+
+function readValue(kv, ...names) {
+  for (const name of names) {
+    if (kv.has(name)) return kv.get(name);
+  }
+  return null;
+}
+
+function textSummary(result) {
+  const memory = result.summary.memory;
+  const cpu = result.summary.cpu;
+  const lines = [
+    `[profile-processes] pid ${result.target.pid} sampled ${result.summary.sampleCount} times over ${result.summary.durationMs}ms`,
+    `[profile-processes] CPU avg ${cpu.averagePercent}% max ${cpu.maxPercent}%`,
+    `[profile-processes] RSS start ${memory.rssStartBytes} B, end ${memory.rssEndBytes} B, delta ${memory.rssDeltaBytes} B, growth/min ${memory.rssGrowthPerMinuteBytes} B`,
+    `[profile-processes] samples: ${result.artifacts.samples}`,
+    `[profile-processes] summary: ${result.artifacts.summary}`,
+  ];
+  if (result.cpuProfile) {
+    lines.push(
+      result.cpuProfile.ok
+        ? `[profile-processes] cpu sample: ${result.cpuProfile.file}`
+        : `[profile-processes] cpu sample failed: ${result.cpuProfile.error ?? result.cpuProfile.stderr ?? 'unknown error'}`,
+    );
+  }
+  if (result.memoryMaps) {
+    lines.push(`[profile-processes] vmmap summary: ${result.artifacts.vmmapEnd}`);
+  }
+  return lines.join('\n');
+}
+
+export async function runProfileProcessesCli(argv = process.argv.slice(2)) {
+  const { flags, kv } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+
+  if (wantsHelp(argv, { flags })) {
+    printResult({ json, data: { usage: usage() }, text: usage() });
+    return;
+  }
+
+  const pidRaw = readValue(kv, '--pid');
+  const commandMatch = readValue(kv, '--command-match');
+  const targetInput = {
+    pid: pidRaw == null ? null : parsePositiveInteger(pidRaw, 'pid'),
+    commandMatch,
+  };
+
+  const durationMs = parseDurationMs(readValue(kv, '--duration', '--duration-ms'), 'duration') ?? DEFAULT_PROFILE_DURATION_MS;
+  const intervalMs = parseDurationMs(readValue(kv, '--interval', '--interval-ms'), 'interval') ?? DEFAULT_PROFILE_INTERVAL_MS;
+  const cpuProfileMs =
+    parseDurationMs(readValue(kv, '--stack-sample', '--stack-sample-ms', '--cpu-profile', '--cpu-profile-ms'), 'stack-sample') ?? 0;
+  const sampleIntervalMs =
+    readValue(kv, '--sample-interval', '--sample-interval-ms') == null
+      ? DEFAULT_CPU_SAMPLE_INTERVAL_MS
+      : parsePositiveInteger(readValue(kv, '--sample-interval', '--sample-interval-ms'), 'sample-interval');
+  const outputDir = readValue(kv, '--out-dir') ?? join(tmpdir(), 'happier-process-profiles');
+  const label = readValue(kv, '--label') ?? (targetInput.commandMatch ? targetInput.commandMatch : null);
+  const memoryMap = flags.has('--memory-map');
+  const dryRun = flags.has('--dry-run') || flags.has('--print-plan');
+
+  if (dryRun) {
+    const target = await resolveProcessTarget(targetInput);
+    const plan = {
+      target,
+      outputDir,
+      parameters: { durationMs, intervalMs, cpuProfileMs, sampleIntervalMs, memoryMap },
+    };
+    printResult({
+      json,
+      data: plan,
+      text: [
+        `[profile-processes] target pid: ${target.pid}`,
+        `[profile-processes] output dir: ${outputDir}`,
+        `[profile-processes] duration: ${durationMs}ms; interval: ${intervalMs}ms`,
+        cpuProfileMs ? `[profile-processes] cpu sample: ${cpuProfileMs}ms @ ${sampleIntervalMs}ms` : '[profile-processes] cpu sample: disabled',
+        memoryMap ? '[profile-processes] vmmap summary: enabled' : '[profile-processes] vmmap summary: disabled',
+      ].join('\n'),
+    });
+    return;
+  }
+
+  const result = await runProcessProfile({
+    ...targetInput,
+    label,
+    outputDir,
+    durationMs,
+    intervalMs,
+    cpuProfileMs,
+    sampleIntervalMs,
+    memoryMap,
+  });
+
+  printResult({ json, data: result, text: textSummary(result) });
+
+  if (result.cpuProfile && !result.cpuProfile.ok) {
+    process.exitCode = 1;
+  }
+  if (result.memoryMaps && [result.memoryMaps.start, result.memoryMaps.end].some((entry) => entry && !entry.ok)) {
+    process.exitCode = 1;
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  runProfileProcessesCli().catch((err) => {
+    console.error('[profile-processes] failed:', err);
+    process.exit(1);
+  });
+}

package/scripts/profiling/ios_xctrace_memory_diagnostics.mjs

@@ -0,0 +1,91 @@
+function includesPattern(text, pattern) {
+  return pattern.test(String(text ?? ''));
+}
+
+function collectCodeSigningEvidence(unifiedLog) {
+  const log = String(unifiedLog ?? '');
+  return {
+    codeValidityError67050: includesPattern(log, /Code validity check error:.*Code=-67050/i),
+    amfiUnknownCertificateChain: includesPattern(log, /amfid.*adhoc signed or signed by an unknown certificate chain/i),
+    detachedSignaturesMissing: includesPattern(log, /open\(\/private\/var\/db\/DetachedSignatures\).*No such file or directory/i),
+  };
+}
+
+function hasCodeSigningEvidence(evidence) {
+  return Boolean(
+    evidence.codeValidityError67050 ||
+      evidence.amfiUnknownCertificateChain ||
+      evidence.detachedSignaturesMissing,
+  );
+}
+
+function classifyRecordFailure(recordLog) {
+  const log = String(recordLog ?? '');
+  if (includesPattern(log, /Unable to instantiate loader for target/i)) {
+    return 'target-loader-unavailable';
+  }
+  if (includesPattern(log, /Failed to acquire memory location for pushing shared memory into target/i)) {
+    return 'target-shared-memory-injection-unavailable';
+  }
+  if (includesPattern(log, /Failed to load library .*liboainject\.dylib.*target process .* appears to have exited/i)) {
+    return 'liboainject-target-exited';
+  }
+  if (includesPattern(log, /Target process is marked restricted and cannot be traced while System Integrity Protection is enabled/i)) {
+    return 'sip-restricted-target';
+  }
+  if (includesPattern(log, /Recording failed with errors|Run issues were detected/i)) {
+    return 'recording-failed';
+  }
+  return null;
+}
+
+function classifyExportFailure({ exportLog, tocBytes }) {
+  const log = String(exportLog ?? '');
+  if (tocBytes != null && Number(tocBytes) === 0) {
+    return 'trace-export-unusable';
+  }
+  if (includesPattern(log, /Export failed|Document Missing Template Error|timed_out=1/i)) {
+    return 'trace-export-unusable';
+  }
+  return null;
+}
+
+export function classifyXctraceMemoryDiagnostics({
+  recordLog = '',
+  exportLog = '',
+  unifiedLog = '',
+  tocBytes = null,
+} = {}) {
+  const codeSigningEvidence = collectCodeSigningEvidence(unifiedLog);
+  const exportReason = classifyExportFailure({ exportLog, tocBytes });
+  const recordReason = classifyRecordFailure(recordLog);
+  const primaryReason = recordReason ?? exportReason ?? 'available';
+  const available = primaryReason === 'available' && Number(tocBytes ?? 1) > 0;
+
+  const recommendedNextStep = (() => {
+    if (available) return 'export-and-parse-allocation-tables';
+    if (
+      primaryReason === 'target-loader-unavailable' ||
+      primaryReason === 'target-shared-memory-injection-unavailable' ||
+      primaryReason === 'liboainject-target-exited'
+    ) {
+      return hasCodeSigningEvidence(codeSigningEvidence)
+        ? 'fix-instruments-target-code-signing-or-use-non-loader-memory-signal'
+        : 'verify-xcode-instruments-loader-with-local-control';
+    }
+    if (primaryReason === 'trace-export-unusable') {
+      return 'discard-failed-trace-and-use-bounded-xctrace-preflight';
+    }
+    if (primaryReason === 'sip-restricted-target') {
+      return 'use-a-non-system-target-or-disable-sip-only-on-a-dedicated-profiling-machine';
+    }
+    return 'use-non-loader-memory-signal-and-capture-xcode-toolchain-diagnostics';
+  })();
+
+  return {
+    available,
+    primaryReason,
+    codeSigningEvidence,
+    recommendedNextStep,
+  };
+}

package/scripts/profiling/ios_xctrace_memory_diagnostics.test.mjs

@@ -0,0 +1,72 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { classifyXctraceMemoryDiagnostics } from './ios_xctrace_memory_diagnostics.mjs';
+
+test('classifyXctraceMemoryDiagnostics identifies loader injection failure with code validity evidence', () => {
+  const result = classifyXctraceMemoryDiagnostics({
+    recordLog: `
+Run issues were detected:
+* [Error] Failed to attach to target process
+  * [Error] Unable to instantiate loader for target.
+`,
+    unifiedLog: `
+com.apple.dt.instruments.dtsecurity Code validity check error: Error Domain=NSOSStatusErrorDomain Code=-67050 "(null)"
+`,
+  });
+
+  assert.equal(result.available, false);
+  assert.equal(result.primaryReason, 'target-loader-unavailable');
+  assert.equal(result.codeSigningEvidence.codeValidityError67050, true);
+  assert.equal(result.recommendedNextStep, 'fix-instruments-target-code-signing-or-use-non-loader-memory-signal');
+});
+
+test('classifyXctraceMemoryDiagnostics identifies launch-time shared-memory injection failure', () => {
+  const result = classifyXctraceMemoryDiagnostics({
+    recordLog: 'Failed to acquire memory location for pushing shared memory into target.',
+  });
+
+  assert.equal(result.available, false);
+  assert.equal(result.primaryReason, 'target-shared-memory-injection-unavailable');
+});
+
+test('classifyXctraceMemoryDiagnostics identifies liboainject target-exit failure', () => {
+  const result = classifyXctraceMemoryDiagnostics({
+    recordLog: 'Failed to load library /Applications/Xcode.app/.../liboainject.dylib because target process 123 appears to have exited',
+  });
+
+  assert.equal(result.available, false);
+  assert.equal(result.primaryReason, 'liboainject-target-exited');
+});
+
+test('classifyXctraceMemoryDiagnostics identifies unusable failed-trace exports', () => {
+  const result = classifyXctraceMemoryDiagnostics({
+    recordLog: 'Starting recording with the Allocations template.',
+    exportLog: 'Export failed: Document Missing Template Error',
+    tocBytes: 0,
+  });
+
+  assert.equal(result.available, false);
+  assert.equal(result.primaryReason, 'trace-export-unusable');
+});
+
+test('classifyXctraceMemoryDiagnostics treats zero-byte TOC as unusable even without exporter stderr', () => {
+  const result = classifyXctraceMemoryDiagnostics({
+    exportLog: '',
+    tocBytes: 0,
+  });
+
+  assert.equal(result.available, false);
+  assert.equal(result.primaryReason, 'trace-export-unusable');
+});
+
+test('classifyXctraceMemoryDiagnostics reports success only when recording and export evidence are clean', () => {
+  const result = classifyXctraceMemoryDiagnostics({
+    recordLog: 'Recording completed successfully. Output file saved as: allocations.trace',
+    tocBytes: 1024,
+  });
+
+  assert.equal(result.available, true);
+  assert.equal(result.primaryReason, 'available');
+  assert.equal(result.recommendedNextStep, 'export-and-parse-allocation-tables');
+});