@legionworks/facet 1.9.0

package/src/shared/logging/redact.ts

@@ -0,0 +1,49 @@
+/**
+ * Recursive redaction. Any property whose KEY (case-insensitive) matches
+ * one of the names below has its VALUE replaced with `REDACT_PLACEHOLDER`.
+ * Values themselves are NEVER inspected for substring matches — only key
+ * names. This keeps accidental "value contained the word 'token'" leaks
+ * out of the redaction path and makes the policy predictable.
+ */
+
+export const REDACT_PLACEHOLDER = "[REDACTED]" as const;
+
+const REDACTED_KEYS = new Set(
+  [
+    "token",
+    "authorization",
+    "source",
+    "content",
+    "html",
+    "svg",
+    "screenshot",
+    "dom",
+    "console",
+  ].map((k) => k.toLowerCase()),
+);
+
+function shouldRedactKey(key: string): boolean {
+  return REDACTED_KEYS.has(key.toLowerCase());
+}
+
+function scrub(value: unknown): unknown {
+  if (value === null || value === undefined) return value;
+  if (Array.isArray(value)) return value.map(scrub);
+  if (typeof value === "object") {
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+      out[k] = shouldRedactKey(k) ? REDACT_PLACEHOLDER : scrub(v);
+    }
+    return out;
+  }
+  return value;
+}
+
+/**
+ * Return a redacted deep-copy of `value`. Primitives pass through;
+ * arrays and objects are walked recursively. See the file header for
+ * the exact redaction policy.
+ */
+export function redact(value: unknown): unknown {
+  return scrub(value);
+}

package/src/shared/security/frozen-csp.ts

@@ -0,0 +1,13 @@
+export const FROZEN_CSP_TEMPLATE =
+  "default-src 'none'; " +
+  "script-src 'nonce-<BOOTSTRAP_NONCE>'; " +
+  "style-src 'unsafe-inline'; " +
+  "img-src data: https:; " +
+  "font-src data:; " +
+  "worker-src 'none'; " +
+  "connect-src 'none'; " +
+  "object-src 'none'; " +
+  "base-uri 'none'; " +
+  "form-action 'none'; " +
+  "frame-src 'none'; " +
+  "media-src 'none'";

package/src/shared/storage-version.ts

@@ -0,0 +1,2 @@
+/** Latest schema migration applied by the service. */
+export const CURRENT_STORAGE_VERSION = 9 as const;

package/src/shared/tsx/execution.ts

@@ -0,0 +1,29 @@
+/**
+ * Canonical TSX execution modes (D2 of the TSX design).
+ *
+ * `--execution` is a DECLARED mode, not an inferred one. The artifact
+ * author states which mode the TSX is meant to render under; the
+ * trust core then applies the matching verification path:
+ *
+ *   - `static`       — compiles to HTML via the existing static HTML
+ *                      pipeline; full predict-and-compare claim.
+ *   - `interactive`  — executes the compiled bundle in a nested
+ *                      opaque-origin frame; observation-only claim.
+ *
+ * Inference from hook or handler usage was rejected during design:
+ * it is fragile and makes the trust claim a function of a heuristic
+ * rather than an operator declaration. A static artifact that
+ * accidentally trips an inference rule would silently earn the weaker
+ * verdict.
+ *
+ * The exported constant is the single source of truth for TypeScript
+ * consumers; the storage CHECK derives its SQL literal from it at schema-build
+ * time so a new mode lands in the database contract too.
+ */
+
+export const TSX_EXECUTION_MODES = ["static", "interactive"] as const;
+export type TsxExecutionMode = (typeof TSX_EXECUTION_MODES)[number];
+
+export function isTsxExecutionMode(value: unknown): value is TsxExecutionMode {
+  return typeof value === "string" && TSX_EXECUTION_MODES.includes(value as TsxExecutionMode);
+}

package/src/shared/tsx/import-policy.ts

@@ -0,0 +1,94 @@
+/**
+ * Fixed TSX import allowlist.
+ *
+ * D6 of the TSX design: compilation runs inside the netns worker with no
+ * egress. The import set is a fixed vendored allowlist:
+ *   - `react`, `react-dom`, and `react-dom/client` (default exports);
+ *   - the JSX runtimes `react/jsx-runtime` and `react/jsx-dev-runtime`.
+ *
+ * Arbitrary npm is rejected outright: resolving dependencies at publish
+ * time would put network egress in the middle of the validation path,
+ * which the trust core forbids. A dependency that is not vendored is not
+ * available.
+ *
+ * Policy is exposed as plain data so the AST walker and the boundary
+ * check can both consume the same source of truth.
+ */
+
+export const TSX_ALLOWED_MODULES = new Set([
+  "react",
+  "react-dom",
+  "react-dom/client",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime",
+]);
+
+export type TsxImportDenialReason =
+  | "tsx_import_relative"
+  | "tsx_import_url"
+  | "tsx_import_not_allowlisted";
+
+export interface TsxImportDenial {
+  readonly code: "tsx_import_denied";
+  readonly message: string;
+  readonly module: string;
+  readonly reason: TsxImportDenialReason;
+}
+
+/**
+ * Decide whether a single import specifier is allowed under D6.
+ *
+ * Reject rules, in order:
+ *   1. Anything that looks like a URL (starts with a scheme, `//`, or a
+ *      `data:` prefix) — `tsx_import_url`.
+ *   2. Relative imports (`.`, `..`, `/`) — `tsx_import_relative`.
+ *   3. Any package that is not in `TSX_ALLOWED_MODULES` — `tsx_import_not_allowlisted`.
+ *
+ * Returns `null` when the specifier is allowed.
+ */
+export function classifyTsxImport(specifier: string): TsxImportDenial | null {
+  if (
+    specifier.startsWith("data:") ||
+    specifier.startsWith("http:") ||
+    specifier.startsWith("https:") ||
+    specifier.startsWith("file:") ||
+    specifier.startsWith("//")
+  ) {
+    return {
+      code: "tsx_import_denied",
+      message: `TSX import not allowed: URL specifier "${specifier}"`,
+      module: specifier,
+      reason: "tsx_import_url",
+    };
+  }
+  if (
+    specifier.startsWith("./") ||
+    specifier.startsWith("../") ||
+    specifier === "." ||
+    specifier === ".."
+  ) {
+    return {
+      code: "tsx_import_denied",
+      message: `TSX import not allowed: relative specifier "${specifier}"`,
+      module: specifier,
+      reason: "tsx_import_relative",
+    };
+  }
+  if (specifier.startsWith("/")) {
+    return {
+      code: "tsx_import_denied",
+      message: `TSX import not allowed: absolute path "${specifier}"`,
+      module: specifier,
+      reason: "tsx_import_relative",
+    };
+  }
+  if (!TSX_ALLOWED_MODULES.has(specifier)) {
+    return {
+      code: "tsx_import_denied",
+      message: `TSX import not allowed: "${specifier}" is not in the vendored allowlist`,
+      module: specifier,
+      reason: "tsx_import_not_allowlisted",
+    };
+  }
+  return null;
+}

package/src/shared/util/dir-permissions.ts

@@ -0,0 +1,94 @@
+/**
+ * Owner-only directory creation.
+ *
+ * The helper has THREE distinct semantics for THREE distinct segment
+ * classes. A regression on any of them breaks either security (the
+ * leaf not 0o700) or shared-tree surprise (a pre-existing ancestor
+ * silently re-moded).
+ *
+ *   1. LEAF (the security target): ALWAYS 0o700. Created at 0o700 if
+ *      missing; chmod'd to 0o700 if pre-existing at a wrong mode.
+ *
+ *   2. Intermediate ancestors the helper CREATES (didn't exist
+ *      before this call): 0o700. The chmod-after-mkrid cycle beats
+ *      an overlapping process umask (e.g. 0o177 strips the owner
+ *      execute bit, breaking a deeper mkdir).
+ *
+ *   3. PRE-EXISTING intermediate ancestors (any dir that already
+ *      existed before this call): UNTOUCHED. The helper must NEVER
+ *      chmod a directory it did not create — silently re-moding a
+ *      shared tree (e.g. ~/.local/state) would surprise every other
+ *      app / backup sharing it.
+ *
+ * Used by:
+ *   - `src/service/store/evidence-retention.ts` for the evidence root
+ *     and the per-run subdirectory
+ *   - `src/validation/tier1/runner.ts` for the per-run evidence
+ *     directory the runner captures screenshots / console summaries
+ *     / protocol observations into
+ *   - `src/service/security/token-store.ts` for the install-token
+ *     directory
+ *   - `src/service/lifecycle/process-lock.ts` for the process-lock
+ *     directory
+ *   - `src/service/store/database.ts` for the SQLite database dir
+ *
+ * The capability-scoped callers (service + validation) MUST go
+ * through this helper so a fix lands in one place.
+ */
+
+import { chmodSync, existsSync, mkdirSync, statSync } from "node:fs";
+import { dirname } from "node:path";
+
+/** Owner-only mode — the canonical secret-bearing layout. */
+export const OWNER_ONLY_MODE = 0o700;
+
+export function ensureOwnerOnlyDirectory(path: string): string {
+  // Walk leaf-up. The first existing ancestor stops the walk; it (and
+  // every directory above it) is pre-existing and must NOT be touched.
+  // If the leaf itself exists, mark it for the leaf-tighten pass.
+  const missing: string[] = [];
+  let cursor: string | null = path;
+  let leafExists = false;
+  while (cursor !== null && cursor.length > 0) {
+    if (existsSync(cursor)) {
+      if (cursor === path) leafExists = true;
+      break;
+    }
+    missing.push(cursor);
+    const parent: string = dirname(cursor);
+    cursor = parent === cursor ? null : parent;
+  }
+
+  // Create missing ancestors top-down. Each newly-created segment
+  // lands at 0o700 (chmod after mkdir beats an overlapping umask).
+  // Pre-existing ancestors are not in `missing` — they're never
+  // chmod'd by this loop.
+  for (const segment of missing.toReversed()) {
+    mkdirSync(segment, { mode: OWNER_ONLY_MODE });
+    try {
+      chmodSync(segment, OWNER_ONLY_MODE);
+    } catch {
+      // best-effort chmod; ENOENT races with a concurrent teardown.
+    }
+  }
+
+  // LEAF enforcement. If the leaf was missing, the loop above just
+  // created it at 0o700. If it pre-existed at a wrong mode, tighten it
+  // now — the leaf is the security target and is always enforced.
+  if (leafExists) {
+    try {
+      const stat = statSync(path);
+      if ((stat.mode & 0o777) !== OWNER_ONLY_MODE) {
+        try {
+          chmodSync(path, OWNER_ONLY_MODE);
+        } catch {
+          // best-effort
+        }
+      }
+    } catch {
+      // ignore — best-effort leaf tightening
+    }
+  }
+
+  return path;
+}

package/src/shared/util/mermaid-nodes.ts

@@ -0,0 +1,230 @@
+/**
+ * Canonical lexical prediction for Mermaid flowchart `g.node` elements.
+ *
+ * Tier 1 observes renderer-owned `.node` groups. This module teaches the
+ * diagram grammars whose output can be predicted reliably; callers receive
+ * `null` rather than a misleading zero for every other diagram type.
+ */
+
+const FLOWCHART_HEADER_RE = /^(?:flowchart|graph)\b/i;
+const SEQUENCE_HEADER_RE = /^sequenceDiagram\b/i;
+const STATE_HEADER_RE = /^stateDiagram(?:-v2)?\b/i;
+const IGNORED_LINE_RE = /^(?:classDef|class|click|direction|end|linkStyle|style|subgraph)\b/i;
+const FENCE_LINE_RE = /^(?:`{3,}|~{3,})/;
+
+type MermaidNodeGrammar = "flowchart" | "sequence" | "state" | "unavailable";
+
+function isIdentifierStart(char: string): boolean {
+  return /[A-Za-z_]/.test(char);
+}
+
+function isIdentifierPart(char: string): boolean {
+  return /[A-Za-z0-9_-]/.test(char);
+}
+
+function shapeEnd(line: string, start: number): number | null {
+  const opening = line.slice(start, start + 2);
+  const close =
+    opening === "[["
+      ? "]]"
+      : opening === "[("
+        ? ")]"
+        : opening === "[/"
+          ? "\\]"
+          : opening === "[\\"
+            ? "/]"
+            : opening === "(("
+              ? "))"
+              : opening === "(["
+                ? "])"
+                : opening === "{{"
+                  ? "}}"
+                  : line[start] === "["
+                    ? "]"
+                    : line[start] === "("
+                      ? ")"
+                      : line[start] === "{"
+                        ? "}"
+                        : line[start] === ">"
+                          ? "]"
+                          : null;
+  if (close === null) return null;
+  const end = line.indexOf(close, start + (opening === "{{" ? 2 : 1));
+  return end === -1 ? line.length : end + close.length;
+}
+
+function grammarFor(text: string): MermaidNodeGrammar {
+  let inDirective = false;
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (FENCE_LINE_RE.test(line)) continue;
+    if (inDirective) {
+      if (line.includes("}%%")) inDirective = false;
+      continue;
+    }
+    if (line.startsWith("%%{")) {
+      if (!line.includes("}%%")) inDirective = true;
+      continue;
+    }
+    if (line.startsWith("%%")) continue;
+    if (FLOWCHART_HEADER_RE.test(line)) return "flowchart";
+    if (SEQUENCE_HEADER_RE.test(line)) return "sequence";
+    if (STATE_HEADER_RE.test(line)) return "state";
+    return "unavailable";
+  }
+  return "unavailable";
+}
+
+function countFlowchartNodeIds(text: string): number {
+  const ids = new Set<string>();
+  let inDirective = false;
+
+  for (const rawLine of text.split(/\r?\n/)) {
+    let line = rawLine.trim();
+    if (!line) continue;
+    if (FENCE_LINE_RE.test(line)) continue;
+    if (inDirective) {
+      if (line.includes("}%%")) inDirective = false;
+      continue;
+    }
+    if (line.startsWith("%%{")) {
+      if (!line.includes("}%%")) inDirective = true;
+      continue;
+    }
+    const commentStart = line.indexOf("%%");
+    if (commentStart !== -1) line = line.slice(0, commentStart).trim();
+    if (!line || FLOWCHART_HEADER_RE.test(line) || IGNORED_LINE_RE.test(line)) continue;
+
+    // Edge labels are text, never endpoint ids. Strip them before scanning
+    // so `A -->|tier 0| B` cannot add `tier` to the prediction.
+    line = line.replace(/\|[^|]*\|/g, "");
+    let index = 0;
+    let expectingNode = true;
+    while (index < line.length) {
+      const char = line[index]!;
+      if (isIdentifierStart(char)) {
+        let end = index + 1;
+        while (end < line.length && isIdentifierPart(line[end]!)) end += 1;
+        const id = line.slice(index, end);
+        const endOfShape = shapeEnd(line, end);
+        if (expectingNode || endOfShape !== null) ids.add(id);
+        expectingNode = false;
+        index = endOfShape ?? end;
+        continue;
+      }
+      if (char === "&") {
+        expectingNode = true;
+        index += 1;
+        continue;
+      }
+      if (char === "-" || char === "=" || char === ".") {
+        let end = index + 1;
+        while (end < line.length && /[-=.<>]/.test(line[end]!)) end += 1;
+        if (end - index >= 2) expectingNode = true;
+        index = end;
+        continue;
+      }
+      index += 1;
+    }
+  }
+  return ids.size;
+}
+
+function stateOperand(line: string): string | null {
+  const trimmed = line.trim();
+  if (trimmed === "[*]") return trimmed;
+  const match = trimmed.match(/^[A-Za-z_][A-Za-z0-9_-]*/);
+  return match?.[0] ?? null;
+}
+
+function compositeStateId(line: string): string | null {
+  const match = line.match(
+    /^state\s+(?:"(?:[^"\\]|\\.)*"\s+as\s+)?([A-Za-z_][A-Za-z0-9_-]*)\s*\{\s*$/i,
+  );
+  return match?.[1] ?? null;
+}
+
+/**
+ * State diagrams render composite states as clusters rather than `g.node`
+ * groups. Pseudo-states coalesce by scope and direction, while inline notes
+ * are `g.node` groups. Mermaid's parser only reports the diagram type, so
+ * this is the smallest grammar needed to match the renderer-owned census.
+ */
+function countStateNodeGroups(text: string): number {
+  const states = new Set<string>();
+  const compositeStates = new Set<string>();
+  const pseudoStates = new Set<string>();
+  const scopes = ["root"];
+  let nextScope = 0;
+  let notes = 0;
+  let inDirective = false;
+
+  for (const rawLine of text.split(/\r?\n/)) {
+    let line = rawLine.trim();
+    if (!line) continue;
+    if (inDirective) {
+      if (line.includes("}%%")) inDirective = false;
+      continue;
+    }
+    if (line.startsWith("%%{")) {
+      if (!line.includes("}%%")) inDirective = true;
+      continue;
+    }
+    const commentStart = line.indexOf("%%");
+    if (commentStart !== -1) line = line.slice(0, commentStart).trim();
+    if (!line || STATE_HEADER_RE.test(line)) continue;
+
+    const composite = compositeStateId(line);
+    if (composite !== null) {
+      compositeStates.add(composite);
+      nextScope += 1;
+      scopes.push(`scope-${nextScope}`);
+      continue;
+    }
+    if (line === "}") {
+      scopes.pop();
+      continue;
+    }
+    if (/^note\b/i.test(line)) {
+      notes += 1;
+      continue;
+    }
+
+    const arrow = line.indexOf("-->");
+    if (arrow === -1) continue;
+    const left = stateOperand(line.slice(0, arrow));
+    const right = stateOperand(line.slice(arrow + 3).split(":", 1)[0] ?? "");
+    const scope = scopes.at(-1) ?? "root";
+    for (const operand of [left, right]) {
+      if (operand === null) continue;
+      if (operand !== "[*]") states.add(operand);
+    }
+    if (left === "[*]") pseudoStates.add(`${scope}:entry`);
+    if (right === "[*]") pseudoStates.add(`${scope}:exit`);
+  }
+  let leafStates = 0;
+  for (const state of states) {
+    if (!compositeStates.has(state)) leafStates += 1;
+  }
+  return leafStates + pseudoStates.size + notes;
+}
+
+/**
+ * Return the lexical expectation for Tier 1's Mermaid `g.node` census.
+ * `null` means the diagram type has no maintained grammar and must skip the
+ * node comparison; it is deliberately distinct from the exact zero for
+ * sequence diagrams, which render no `g.node` groups.
+ */
+export function countMermaidNodeDeclarations(text: string): number | null {
+  switch (grammarFor(text)) {
+    case "flowchart":
+      return countFlowchartNodeIds(text);
+    case "sequence":
+      return 0;
+    case "state":
+      return countStateNodeGroups(text);
+    case "unavailable":
+      return null;
+  }
+}

package/src/shared/util/process.ts

@@ -0,0 +1,67 @@
+/**
+ * Canonical OS-process helpers shared by every service layer that
+ * needs to detect a live pid or read its monotonic start time
+ * without taking responsibility for the full lock lifecycle. The
+ * lock module (`service/lifecycle/process-lock`) and the Tier 1
+ * verifier (`validation/tier1/browser-process`) both import from
+ * here so a single bug fix lands in one place.
+ */
+
+import { readFileSync } from "node:fs";
+
+/**
+ * Probe whether `pid` is alive. Returns true when `process.kill(pid, 0)`
+ * succeeds OR returns EPERM (the pid exists but the caller cannot
+ * signal it — treat as alive so we never reclaim a foreign-pid lock
+ * whose ownership we cannot independently prove). False for
+ * non-positive / non-integer pids, for ESRCH (pid does not exist),
+ * and for any other error code (conservative: the caller decides
+ * whether a non-zero non-EPERM error is "dead" or "indeterminate";
+ * in practice every other kill-0 failure on Linux is ESRCH).
+ */
+export function isPidAlive(pid: number): boolean {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === "EPERM") return true;
+    return false;
+  }
+}
+
+/**
+ * Read the OS-recorded process start time (clock ticks since boot,
+ * field 22 of /proc/<pid>/stat) for a live pid. Returns null when
+ * the pid is unreadable (non-integer, non-positive, /proc entry
+ * missing, or the start-time field is non-numeric).
+ *
+ * The Linux start-time field is monotonic and stable across the
+ * lifetime of the process, which makes it a far stronger staleness
+ * signal than wall-clock time — two pids with the same start-time
+ * ticks are guaranteed to be the same process. Both
+ * `service/lifecycle/process-lock` (lock metadata) and
+ * `validation/tier1/browser-process` (browser pid record for orphan
+ * cleanup) read this same field so a future orphan-cleanup hook can
+ * cross-reference the two with byte-identical semantics.
+ */
+export function readPidStartTimeTicks(pid: number): number | null {
+  if (!Number.isInteger(pid) || pid <= 0) return null;
+  try {
+    const text = readFileSync(`/proc/${pid}/stat`, "utf8");
+    // /proc/<pid>/stat: "pid (comm) state ppid ..." — the comm field
+    // can contain spaces or parens, so find the LAST `)` and parse
+    // from there.
+    const lastParen = text.lastIndexOf(")");
+    if (lastParen < 0) return null;
+    const after = text.slice(lastParen + 1).trimStart();
+    const fields = after.split(/\s+/);
+    // The slice starts at field 3 (`state`), so field 22 is index 19.
+    const startTime = Number(fields[19]);
+    if (!Number.isFinite(startTime)) return null;
+    return startTime;
+  } catch {
+    return null;
+  }
+}

package/src/shared/util/time.ts

@@ -0,0 +1,21 @@
+/**
+ * Canonical timestamp + id helpers.
+ *
+ * Every persisted record stamps itself with `new Date().toISOString()`
+ * — single source of truth so wire timestamps and DB timestamps share
+ * the same shape (RFC 3339, millisecond precision, trailing `Z`).
+ *
+ * `generateRequestId` was duplicated between the service's
+ * `http-utils.ts` and the CLI; both files now import from here so the
+ * format (`req-<uuid>`) cannot drift.
+ */
+
+import { randomUUID } from "node:crypto";
+
+export function now(): string {
+  return new Date().toISOString();
+}
+
+export function generateRequestId(): string {
+  return `req-${randomUUID()}`;
+}

package/src/shared/version.ts

@@ -0,0 +1,3 @@
+import packageJson from "../../package.json" with { type: "json" };
+
+export const FACET_VERSION = packageJson.version;

package/src/validation/sandbox/limits.ts

@@ -0,0 +1,41 @@
+/**
+ * Resource caps applied to the Tier 0 parse worker.
+ *
+ * Each cap is named and exposed so tests, the runner, and the netns
+ * wrapper can agree on a single value. A failing cap produces a typed
+ * Tier 0 failure (timeout, output cap, …) that the parent maps to a
+ * `Tier0Result` (or, when the worker cannot even start, a typed
+ * `FacetError`).
+ */
+
+/** Wall-clock budget for one Tier 0 worker invocation. */
+export const TIER0_TIMEOUT_MS = 5_000;
+
+/**
+ * TSX includes worker boot, a cold Bun.build, and static SSR in this budget:
+ * the parent starts the timer before the pooled worker has imported Bun and React.
+ */
+export const TIER0_TSX_COLD_P95_BASELINE_MS = 250;
+export const TIER0_TSX_CONTENTION_FACTOR = 3;
+export const TIER0_TSX_TIMEOUT_MS = 2_000;
+
+/**
+ * Maximum number of bytes the worker may write to STDOUT before the
+ * parent truncates the stream and records a typed protocol error.
+ * The cap accommodates bounded compiled TSX evidence while still
+ * catching an unbounded or misbehaving worker.
+ */
+export const TIER0_OUTPUT_CAP_BYTES = 4 * 1024 * 1024;
+
+/** Maximum NDJSON request line accepted by the long-lived Tier 0 worker. */
+export const TIER0_INPUT_CAP_BYTES = 8 * 1024 * 1024;
+
+/**
+ * Linux `setrlimit` cap on the worker's resident memory. Enforced via
+ * `bash -c 'ulimit -v …; exec "$@"'` inside the netns wrapper so the
+ * Bun process inherits the limit on startup. 512 MiB is generous for
+ * `marked`/`mermaid`/`vega-lite` `compile()` on the 5 MiB source cap;
+ * a hostile artifact that allocates past this cap is killed by SIGKILL
+ * and surfaced as `tier0_worker_died`.
+ */
+export const TIER0_MEMORY_CAP_BYTES = 512 * 1024 * 1024;