tsc-ts 0.0.4 → 0.0.5

package/src/compiler/syntax-kind.ts

@@ -0,0 +1,391 @@
+// Generated by scripts/generate.mjs. Do not edit.
+
+/** Syntax kinds, numbered like TypeScript 7. */
+export const enum SyntaxKind {
+  Unknown = 0,
+  EndOfFile = 1,
+  SingleLineCommentTrivia = 2,
+  MultiLineCommentTrivia = 3,
+  NewLineTrivia = 4,
+  WhitespaceTrivia = 5,
+  ConflictMarkerTrivia = 6,
+  NonTextFileMarkerTrivia = 7,
+  NumericLiteral = 8,
+  BigIntLiteral = 9,
+  StringLiteral = 10,
+  JsxText = 11,
+  JsxTextAllWhiteSpaces = 12,
+  RegularExpressionLiteral = 13,
+  NoSubstitutionTemplateLiteral = 14,
+  TemplateHead = 15,
+  TemplateMiddle = 16,
+  TemplateTail = 17,
+  OpenBraceToken = 18,
+  CloseBraceToken = 19,
+  OpenParenToken = 20,
+  CloseParenToken = 21,
+  OpenBracketToken = 22,
+  CloseBracketToken = 23,
+  DotToken = 24,
+  DotDotDotToken = 25,
+  SemicolonToken = 26,
+  CommaToken = 27,
+  QuestionDotToken = 28,
+  LessThanToken = 29,
+  LessThanSlashToken = 30,
+  GreaterThanToken = 31,
+  LessThanEqualsToken = 32,
+  GreaterThanEqualsToken = 33,
+  EqualsEqualsToken = 34,
+  ExclamationEqualsToken = 35,
+  EqualsEqualsEqualsToken = 36,
+  ExclamationEqualsEqualsToken = 37,
+  EqualsGreaterThanToken = 38,
+  PlusToken = 39,
+  MinusToken = 40,
+  AsteriskToken = 41,
+  AsteriskAsteriskToken = 42,
+  SlashToken = 43,
+  PercentToken = 44,
+  PlusPlusToken = 45,
+  MinusMinusToken = 46,
+  LessThanLessThanToken = 47,
+  GreaterThanGreaterThanToken = 48,
+  GreaterThanGreaterThanGreaterThanToken = 49,
+  AmpersandToken = 50,
+  BarToken = 51,
+  CaretToken = 52,
+  ExclamationToken = 53,
+  TildeToken = 54,
+  AmpersandAmpersandToken = 55,
+  BarBarToken = 56,
+  QuestionToken = 57,
+  ColonToken = 58,
+  AtToken = 59,
+  QuestionQuestionToken = 60,
+  BacktickToken = 61,
+  HashToken = 62,
+  EqualsToken = 63,
+  PlusEqualsToken = 64,
+  MinusEqualsToken = 65,
+  AsteriskEqualsToken = 66,
+  AsteriskAsteriskEqualsToken = 67,
+  SlashEqualsToken = 68,
+  PercentEqualsToken = 69,
+  LessThanLessThanEqualsToken = 70,
+  GreaterThanGreaterThanEqualsToken = 71,
+  GreaterThanGreaterThanGreaterThanEqualsToken = 72,
+  AmpersandEqualsToken = 73,
+  BarEqualsToken = 74,
+  BarBarEqualsToken = 75,
+  AmpersandAmpersandEqualsToken = 76,
+  QuestionQuestionEqualsToken = 77,
+  CaretEqualsToken = 78,
+  Identifier = 79,
+  PrivateIdentifier = 80,
+  JSDocCommentTextToken = 81,
+  BreakKeyword = 82,
+  CaseKeyword = 83,
+  CatchKeyword = 84,
+  ClassKeyword = 85,
+  ConstKeyword = 86,
+  ContinueKeyword = 87,
+  DebuggerKeyword = 88,
+  DefaultKeyword = 89,
+  DeleteKeyword = 90,
+  DoKeyword = 91,
+  ElseKeyword = 92,
+  EnumKeyword = 93,
+  ExportKeyword = 94,
+  ExtendsKeyword = 95,
+  FalseKeyword = 96,
+  FinallyKeyword = 97,
+  ForKeyword = 98,
+  FunctionKeyword = 99,
+  IfKeyword = 100,
+  ImportKeyword = 101,
+  InKeyword = 102,
+  InstanceOfKeyword = 103,
+  NewKeyword = 104,
+  NullKeyword = 105,
+  ReturnKeyword = 106,
+  SuperKeyword = 107,
+  SwitchKeyword = 108,
+  ThisKeyword = 109,
+  ThrowKeyword = 110,
+  TrueKeyword = 111,
+  TryKeyword = 112,
+  TypeOfKeyword = 113,
+  VarKeyword = 114,
+  VoidKeyword = 115,
+  WhileKeyword = 116,
+  WithKeyword = 117,
+  ImplementsKeyword = 118,
+  InterfaceKeyword = 119,
+  LetKeyword = 120,
+  PackageKeyword = 121,
+  PrivateKeyword = 122,
+  ProtectedKeyword = 123,
+  PublicKeyword = 124,
+  StaticKeyword = 125,
+  YieldKeyword = 126,
+  AbstractKeyword = 127,
+  AccessorKeyword = 128,
+  AsKeyword = 129,
+  AssertsKeyword = 130,
+  AssertKeyword = 131,
+  AnyKeyword = 132,
+  AsyncKeyword = 133,
+  AwaitKeyword = 134,
+  BooleanKeyword = 135,
+  ConstructorKeyword = 136,
+  DeclareKeyword = 137,
+  GetKeyword = 138,
+  ImmediateKeyword = 139,
+  InferKeyword = 140,
+  IntrinsicKeyword = 141,
+  IsKeyword = 142,
+  KeyOfKeyword = 143,
+  ModuleKeyword = 144,
+  NamespaceKeyword = 145,
+  NeverKeyword = 146,
+  OutKeyword = 147,
+  ReadonlyKeyword = 148,
+  RequireKeyword = 149,
+  NumberKeyword = 150,
+  ObjectKeyword = 151,
+  SatisfiesKeyword = 152,
+  SetKeyword = 153,
+  StringKeyword = 154,
+  SymbolKeyword = 155,
+  TypeKeyword = 156,
+  UndefinedKeyword = 157,
+  UniqueKeyword = 158,
+  UnknownKeyword = 159,
+  UsingKeyword = 160,
+  FromKeyword = 161,
+  GlobalKeyword = 162,
+  BigIntKeyword = 163,
+  OverrideKeyword = 164,
+  OfKeyword = 165,
+  DeferKeyword = 166,
+  QualifiedName = 167,
+  ComputedPropertyName = 168,
+  TypeParameter = 169,
+  Parameter = 170,
+  Decorator = 171,
+  PropertySignature = 172,
+  PropertyDeclaration = 173,
+  MethodSignature = 174,
+  MethodDeclaration = 175,
+  ClassStaticBlockDeclaration = 176,
+  Constructor = 177,
+  GetAccessor = 178,
+  SetAccessor = 179,
+  CallSignature = 180,
+  ConstructSignature = 181,
+  IndexSignature = 182,
+  TypePredicate = 183,
+  TypeReference = 184,
+  FunctionType = 185,
+  ConstructorType = 186,
+  TypeQuery = 187,
+  TypeLiteral = 188,
+  ArrayType = 189,
+  TupleType = 190,
+  OptionalType = 191,
+  RestType = 192,
+  UnionType = 193,
+  IntersectionType = 194,
+  ConditionalType = 195,
+  InferType = 196,
+  ParenthesizedType = 197,
+  ThisType = 198,
+  TypeOperator = 199,
+  IndexedAccessType = 200,
+  MappedType = 201,
+  LiteralType = 202,
+  NamedTupleMember = 203,
+  TemplateLiteralType = 204,
+  TemplateLiteralTypeSpan = 205,
+  ImportType = 206,
+  ObjectBindingPattern = 207,
+  ArrayBindingPattern = 208,
+  BindingElement = 209,
+  ArrayLiteralExpression = 210,
+  ObjectLiteralExpression = 211,
+  PropertyAccessExpression = 212,
+  ElementAccessExpression = 213,
+  CallExpression = 214,
+  NewExpression = 215,
+  TaggedTemplateExpression = 216,
+  TypeAssertionExpression = 217,
+  ParenthesizedExpression = 218,
+  FunctionExpression = 219,
+  ArrowFunction = 220,
+  DeleteExpression = 221,
+  TypeOfExpression = 222,
+  VoidExpression = 223,
+  AwaitExpression = 224,
+  PrefixUnaryExpression = 225,
+  PostfixUnaryExpression = 226,
+  BinaryExpression = 227,
+  ConditionalExpression = 228,
+  TemplateExpression = 229,
+  YieldExpression = 230,
+  SpreadElement = 231,
+  ClassExpression = 232,
+  OmittedExpression = 233,
+  ExpressionWithTypeArguments = 234,
+  AsExpression = 235,
+  NonNullExpression = 236,
+  MetaProperty = 237,
+  SyntheticExpression = 238,
+  SatisfiesExpression = 239,
+  TemplateSpan = 240,
+  SemicolonClassElement = 241,
+  Block = 242,
+  EmptyStatement = 243,
+  VariableStatement = 244,
+  ExpressionStatement = 245,
+  IfStatement = 246,
+  DoStatement = 247,
+  WhileStatement = 248,
+  ForStatement = 249,
+  ForInStatement = 250,
+  ForOfStatement = 251,
+  ContinueStatement = 252,
+  BreakStatement = 253,
+  ReturnStatement = 254,
+  WithStatement = 255,
+  SwitchStatement = 256,
+  LabeledStatement = 257,
+  ThrowStatement = 258,
+  TryStatement = 259,
+  DebuggerStatement = 260,
+  VariableDeclaration = 261,
+  VariableDeclarationList = 262,
+  FunctionDeclaration = 263,
+  ClassDeclaration = 264,
+  InterfaceDeclaration = 265,
+  TypeAliasDeclaration = 266,
+  EnumDeclaration = 267,
+  ModuleDeclaration = 268,
+  ModuleBlock = 269,
+  CaseBlock = 270,
+  NamespaceExportDeclaration = 271,
+  ImportEqualsDeclaration = 272,
+  ImportDeclaration = 273,
+  ImportClause = 274,
+  NamespaceImport = 275,
+  NamedImports = 276,
+  ImportSpecifier = 277,
+  ExportAssignment = 278,
+  ExportDeclaration = 279,
+  NamedExports = 280,
+  NamespaceExport = 281,
+  ExportSpecifier = 282,
+  MissingDeclaration = 283,
+  ExternalModuleReference = 284,
+  JsxElement = 285,
+  JsxSelfClosingElement = 286,
+  JsxOpeningElement = 287,
+  JsxClosingElement = 288,
+  JsxFragment = 289,
+  JsxOpeningFragment = 290,
+  JsxClosingFragment = 291,
+  JsxAttribute = 292,
+  JsxAttributes = 293,
+  JsxSpreadAttribute = 294,
+  JsxExpression = 295,
+  JsxNamespacedName = 296,
+  CaseClause = 297,
+  DefaultClause = 298,
+  HeritageClause = 299,
+  CatchClause = 300,
+  ImportAttributes = 301,
+  ImportAttribute = 302,
+  PropertyAssignment = 303,
+  ShorthandPropertyAssignment = 304,
+  SpreadAssignment = 305,
+  EnumMember = 306,
+  SourceFile = 307,
+  JSDocTypeExpression = 308,
+  JSDocNameReference = 309,
+  JSDocAllType = 310,
+  JSDocNullableType = 311,
+  JSDocNonNullableType = 312,
+  JSDocOptionalType = 313,
+  JSDocVariadicType = 314,
+  JSDoc = 315,
+  JSDocText = 316,
+  JSDocTypeLiteral = 317,
+  JSDocSignature = 318,
+  JSDocLink = 319,
+  JSDocLinkCode = 320,
+  JSDocLinkPlain = 321,
+  JSDocUnknownTag = 322,
+  JSDocAugmentsTag = 323,
+  JSDocImplementsTag = 324,
+  JSDocDeprecatedTag = 325,
+  JSDocPublicTag = 326,
+  JSDocPrivateTag = 327,
+  JSDocProtectedTag = 328,
+  JSDocReadonlyTag = 329,
+  JSDocOverrideTag = 330,
+  JSDocCallbackTag = 331,
+  JSDocOverloadTag = 332,
+  JSDocParameterTag = 333,
+  JSDocReturnTag = 334,
+  JSDocThisTag = 335,
+  JSDocTypeTag = 336,
+  JSDocTemplateTag = 337,
+  JSDocTypedefTag = 338,
+  JSDocSeeTag = 339,
+  JSDocPropertyTag = 340,
+  JSDocThrowsTag = 341,
+  JSDocSatisfiesTag = 342,
+  JSDocImportTag = 343,
+  SyntaxList = 344,
+  JSTypeAliasDeclaration = 345,
+  JSImportDeclaration = 346,
+  NotEmittedStatement = 347,
+  PartiallyEmittedExpression = 348,
+  SyntheticReferenceExpression = 349,
+  NotEmittedTypeElement = 350,
+  Count = 351,
+  FirstAssignment = EqualsToken,
+  LastAssignment = CaretEqualsToken,
+  FirstCompoundAssignment = PlusEqualsToken,
+  LastCompoundAssignment = CaretEqualsToken,
+  FirstReservedWord = BreakKeyword,
+  LastReservedWord = WithKeyword,
+  FirstKeyword = BreakKeyword,
+  LastKeyword = DeferKeyword,
+  FirstFutureReservedWord = ImplementsKeyword,
+  LastFutureReservedWord = YieldKeyword,
+  FirstTypeNode = TypePredicate,
+  LastTypeNode = ImportType,
+  FirstPunctuation = OpenBraceToken,
+  LastPunctuation = CaretEqualsToken,
+  FirstToken = Unknown,
+  LastToken = LastKeyword,
+  FirstLiteralToken = NumericLiteral,
+  LastLiteralToken = NoSubstitutionTemplateLiteral,
+  FirstTemplateToken = NoSubstitutionTemplateLiteral,
+  LastTemplateToken = TemplateTail,
+  FirstBinaryOperator = LessThanToken,
+  LastBinaryOperator = CaretEqualsToken,
+  FirstStatement = VariableStatement,
+  LastStatement = DebuggerStatement,
+  FirstNode = QualifiedName,
+  FirstJSDocNode = JSDocTypeExpression,
+  LastJSDocNode = JSDocImportTag,
+  FirstJSDocTagNode = JSDocUnknownTag,
+  LastJSDocTagNode = JSDocImportTag,
+  FirstContextualKeyword = AbstractKeyword,
+  LastContextualKeyword = DeferKeyword,
+  LastUnaryOperator = TildeToken,
+  FirstTriviaToken = SingleLineCommentTrivia,
+  LastTriviaToken = ConflictMarkerTrivia,
+}

package/src/compiler/thread-entry.ts

@@ -0,0 +1,191 @@
+// The threads of tsc-ts: starting them from the main thread, and what a thread runs. The entry module of the
+// executable (main.ts) creates the workers, on itself, and hands each one's `workerData` to `runThread`; the
+// command line supplies what depends on it (`ThreadDrivers`).
+import type { Worker } from 'node:worker_threads';
+import { parentPort } from 'node:worker_threads';
+import { publish, sharesPublishedGraphs } from '@scriptc/threads';
+import { reserveNodeIds, shareNodeIds } from './ast.js';
+import type { OutputWriter } from './compile-program.js';
+import { useThreadTextCaches } from './diagnostics.js';
+import { compareReferencesOfThread, type ReferenceJob, referenceThreads } from './incremental.js';
+import {
+  CheckerResult,
+  checkFromQueue,
+  packResult,
+  packsResults,
+  parallelCheck,
+  recycleFiles,
+} from './parallel-check.js';
+import { type LoadMessage, parallelParse } from './parallel-parse.js';
+import type { ParseThread } from './parse-thread.js';
+import { useLazyJSDocTable } from './parser.js';
+import { CheckedProgram } from './program-checker.js';
+import type { Program } from './program.js';
+import { assignSymbolIdsAtCreation, reserveSymbolIds, shareSymbolIds } from './symbol.js';
+import { mark, setTimelineThread } from './timeline.js';
+
+/** What threads need from the command line that starts them. */
+export interface ThreadDrivers {
+  /** Where checker threads write the files they emit. */
+  outputWriter(): OutputWriter;
+  /** The program of a command line, for a checker thread that builds its own (under Node.js). */
+  programOfCommandLine(args: readonly string[]): Program | undefined;
+  /** A parse thread for the project of a command line and config file, or undefined if it can't be read. */
+  parseThreadOfCommandLine(args: readonly string[], configFileName: string): ParseThread | undefined;
+}
+
+/** Starts a worker that runs `runThread(data)`. */
+export type ThreadSpawn = (data: ThreadData) => Worker;
+
+/** The `workerData` of a thread of tsc-ts. */
+export type ThreadData = CheckerThreadData | ParseThreadData | ReferenceThreadData;
+
+export interface CheckerThreadData {
+  readonly kind: 'check';
+  /** The shared, published program in scriptc builds; undefined under Node.js, where the thread builds its own. */
+  readonly program: Program | undefined;
+  readonly args: readonly string[];
+  readonly index: number;
+  readonly counter: SharedArrayBuffer;
+  readonly order: number[];
+  readonly nodeIds: number;
+  readonly symbolIds: number;
+  readonly reserved: number[];
+  readonly emits: boolean;
+  readonly emitKinds: number[] | undefined;
+  readonly checking: boolean;
+}
+
+export interface ParseThreadData {
+  readonly kind: 'parse';
+  readonly configFileName: string;
+  readonly args: readonly string[];
+  readonly counter: SharedArrayBuffer;
+  readonly index: number;
+}
+
+export interface ReferenceThreadData {
+  readonly kind: 'references';
+  readonly job: ReferenceJob;
+}
+
+/**
+ * Lets `--checkers N` start checker threads that write the files they emit, and parse threads where
+ * threads share objects; `args` is the command line the threads read.
+ */
+export function startThreads(spawn: ThreadSpawn, drivers: ThreadDrivers, args: readonly string[]): void {
+  parallelCheck.writer = drivers.outputWriter();
+  parallelCheck.spawn = (program, index, counter, order, nodeIds, symbolIds, reserved, emits, emitKinds, checking) =>
+    spawn({
+      kind: 'check',
+      program,
+      args,
+      index,
+      counter,
+      order,
+      nodeIds,
+      symbolIds,
+      reserved,
+      emits,
+      emitKinds,
+      checking,
+    });
+  if (sharesPublishedGraphs) {
+    parallelParse.spawn = (configFileName, counter, index) =>
+      spawn({ kind: 'parse', configFileName, args, counter, index });
+    // The main thread compares the files a reference thread that failed did not.
+    referenceThreads.spawn = (job) => {
+      const worker = spawn({ kind: 'references', job });
+      worker.on('error', () => {});
+    };
+  }
+}
+
+/**
+ * Runs the thread that `data`, its `workerData` (a `ThreadData`), describes. The data is read as the type of its
+ * kind: a native build checks `workerData` against the type it is read as.
+ */
+export function runThread(data: unknown, drivers: ThreadDrivers): void {
+  const kind = (data as { kind: string }).kind;
+  if (kind === 'parse') runParseThread(data as ParseThreadData, drivers);
+  else if (kind === 'references') runReferenceThread(data as ReferenceThreadData);
+  else runCheckerThread(data as CheckerThreadData, drivers);
+}
+
+/** A reference thread (incremental.ts): compares the references of the program's files with its old state. */
+function runReferenceThread(data: ReferenceThreadData): void {
+  const job = data.job;
+  setTimelineThread('r' + String(job.index));
+  mark('thread start');
+  // As on a checker thread, the shared program is never written.
+  reserveNodeIds(job.nodeIds);
+  reserveSymbolIds(job.symbolIds);
+  assignSymbolIdsAtCreation();
+  useLazyJSDocTable();
+  useThreadTextCaches();
+  compareReferencesOfThread(publish(job.program), job);
+  mark('references compared');
+}
+
+/** A checker thread (parallel-check.ts). */
+function runCheckerThread(job: CheckerThreadData, drivers: ThreadDrivers): void {
+  const startedAt = Date.now();
+  setTimelineThread('c' + String(job.index));
+  mark('thread start');
+  parallelCheck.writer = drivers.outputWriter();
+  let program: Program | undefined = undefined;
+  if (job.program !== undefined) {
+    // The shared program is never written: new ids continue above its own, and lazily parsed JSDoc
+    // goes to a table of this thread.
+    reserveNodeIds(job.nodeIds);
+    reserveSymbolIds(job.symbolIds);
+    assignSymbolIdsAtCreation();
+    useLazyJSDocTable();
+    useThreadTextCaches();
+    program = publish(job.program);
+    mark('program received');
+  } else program = drivers.programOfCommandLine(job.args);
+  // Without a program this thread checks nothing; the main thread checks the files it would have.
+  const result =
+    program === undefined
+      ? new CheckerResult(job.index, [], [], [], [], 0, [])
+      : checkFromQueue(
+          new CheckedProgram(program),
+          job.index,
+          new Int32Array(job.counter),
+          job.order,
+          startedAt,
+          false,
+          recycleFiles,
+          job.reserved,
+          job.emits,
+          job.emitKinds,
+          job.checking,
+        );
+  // Packed results are copied: nothing this thread allocated stays reachable after it ends.
+  if (packsResults) parentPort!.postMessage(packResult(result, program!));
+  else parentPort!.postMessage({ result: sharesPublishedGraphs ? publish(result) : result });
+  mark('result posted');
+}
+
+/** A parse thread (parallel-parse.ts): loads the chunks the main thread posts until it posts `stop`. */
+function runParseThread(job: ParseThreadData, drivers: ThreadDrivers): void {
+  setTimelineThread('p' + String(job.index));
+  mark('thread start');
+  // Ids, also of the nodes of the config, come in chunks from the counter shared with the other threads.
+  shareNodeIds(new Int32Array(job.counter, 0, 1));
+  shareSymbolIds(new Int32Array(job.counter, 4, 1));
+  assignSymbolIdsAtCreation();
+  // The command line comes from the main thread: native worker threads don't inherit process.argv.
+  const thread = drivers.parseThreadOfCommandLine(job.args, job.configFileName);
+  mark('project read');
+  const port = parentPort!;
+  port.on('message', (message: unknown) => {
+    const chunk = message as LoadMessage;
+    if (chunk.stop) port.close();
+    // The main thread read the project, so this one can too; if not, the program's FileLoader
+    // parses the files of the chunk (the main thread sees this thread fail).
+    else if (thread === undefined) throw new Error('A parse thread could not read the project');
+    else port.postMessage({ batch: thread.load(chunk) });
+  });
+}

package/src/compiler/timeline.ts

@@ -0,0 +1,53 @@
+/**
+ * With TSC_TS_TIMELINE: a timeline of the run on stderr, one event per line as
+ * `@<ms> <thread> <event>`, where `<ms>` is `performance.now()` (in native builds, milliseconds since
+ * the executable was loaded, the same clock on every thread) and `<thread>` is `main`, `p<n>` for a
+ * parse thread or `c<n>` for a checker thread.
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+
+export const timeline = process.env.TSC_TS_TIMELINE !== undefined;
+
+let thread = 'main';
+
+/** Names this thread in the timeline. */
+export function setTimelineThread(name: string): void {
+  thread = name;
+}
+
+/** Writes a timeline event at the current time. */
+export function mark(event: string): void {
+  if (timeline) markAt(performance.now(), event);
+}
+
+/** Writes a timeline event at `ms`. */
+export function markAt(ms: number, event: string): void {
+  if (timeline) process.stderr.write(`@${ms.toFixed(2)} ${thread} ${event}\n`);
+}
+
+/** With TSC_TS_TIMELINE=2: the process's memory summary (Linux `/proc/self/smaps_rollup`, in MB) as a timeline event. */
+export function markMemory(): void {
+  const smaps = process.env.TSC_TS_SMAPS;
+  if (smaps !== undefined) {
+    try {
+      writeFileSync(smaps, readFileSync('/proc/self/smaps', 'utf8'));
+    } catch {
+      // Not Linux.
+    }
+  }
+  if (process.env.TSC_TS_TIMELINE !== '2') return;
+  try {
+    const text = readFileSync('/proc/self/smaps_rollup', 'utf8');
+    let out = 'memory';
+    for (const key of ['Rss', 'Anonymous', 'AnonHugePages', 'Private_Dirty']) {
+      const m = new RegExp(key + ':\\s+(\\d+)').exec(text);
+      if (m !== null) out += ` ${key} ${Math.round(Number(m[1]) / 1024)}`;
+    }
+    const status = readFileSync('/proc/self/status', 'utf8');
+    const pt = /VmPTE:\s+(\d+)/.exec(status);
+    if (pt !== null) out += ` VmPTE ${Math.round(Number(pt[1]) / 1024)}`;
+    mark(out);
+  } catch {
+    mark('memory unavailable');
+  }
+}