assertledger 1.0.0

package/benchmarks/self-hosted-core/README.md

@@ -0,0 +1,113 @@
+# AssertLedger self-hosted core campaign
+
+This campaign challenges AssertLedger's deterministic core with four operator-owned mutations:
+dependent-gate ordering, the exact target-weight boundary, contradictory-attempt stability, and
+duration exclusion from the decision digest. A behavior-equivalent neutral rewrite controls for
+source-shape coupling. The candidate set contains four diagnostic slices, one composite candidate,
+and two intentionally unrelated zero-kill candidates.
+
+The builder accepts an external operator plan only after verifying its exact SHA-256 digest. Create
+the plan outside the candidate-generation step with this exact shape (use an absolute repository
+root and preserve the target order shown here):
+
+```json
+{
+  "schemaVersion": "1.0.0",
+  "campaignId": "assertledger-self-hosted-core-v1",
+  "repositoryRoot": "E:\\testforge",
+  "targetIds": [
+    "target-dependent-gate-order",
+    "target-threshold-strict-greater",
+    "target-stability-completeness-only",
+    "target-duration-in-decision-digest"
+  ],
+  "requiredAttempts": 2,
+  "minimumTargetWeightPermille": 1000,
+  "maximumSelectedCandidates": 4
+}
+```
+
+Freeze its digest, build the deterministic artifacts, then explicitly authorize the unsafe local
+backend:
+
+```text
+tsx benchmarks/self-hosted-core/builder.ts operator-plan.json sha256:<digest> evidence
+assertledger verify evidence/request.json --allow-unsafe-execution --json > evidence/manifest.json
+assertledger replay evidence/manifest.json --json
+```
+
+The request has six worlds, seven candidates, two attempts, and an exact maximum of 96 executions.
+The structured adapter runs either the separate liveness control or only the candidate files using
+`process.execPath`, `--import tsx`, and `--test`, with `shell: false`. The builder binds the
+canonical host `node_modules` path into `request.json`; the adapter mounts it as a directory symlink
+(a junction on Windows) when the disposable workspace has no dependency directory. This keeps
+dependencies out of repository copies while making the host dependency explicit and auditable. The
+adapter admits target evidence only when the existing built AssertLedger reporter attributes every
+candidate failure to `ERR_ASSERTION`.
+
+Limitations: `trusted-local` is explicitly **UNSANDBOXED** and must not receive hostile code. The
+adapter, its host dependency junction, and its built reporter are part of the trusted computing base
+and are not independently authenticated. The request is therefore host-bound. Replay checks the
+manifest's integrity and deterministic semantics; it does not make the campaign a standalone
+reproduction bundle, validate the semantic adequacy of the operator's mutations, or establish
+non-flakiness beyond the two declared attempts.
+
+## Existing-test inventory campaign
+
+`existing-tests-builder.ts` is a separate, additive campaign that measures every current literal
+`it(...)` case in `tests/core.test.ts` independently against the same reference, neutral rewrite,
+and four 250-permille target mutations. The original seven-candidate campaign above remains fixed
+at 96 executions.
+
+The current source snapshot contains **36** literal cases. An earlier planning note mentioned 33;
+the builder intentionally follows and freezes the real checkout rather than silently dropping three
+tests. TypeScript's installed AST API extracts the catalogue. Non-literal titles, duplicate titles,
+ID collisions, syntax errors, and any drift from the frozen count fail the build.
+
+`RESULT-existing-tests-v1.md` is explicitly excluded from the repository snapshot because it is an
+output of this campaign. This prevents the measured report from changing the repository digest it
+reports; the executable builder, adapter, source, tests, and all other documentation remain bound.
+
+Each candidate contains two digest-bound files: a faithful copy of `tests/core.test.ts` whose only
+change is the relative import needed at the candidate depth, and `selection.json`, which binds the
+stable candidate ID, literal title, exact escaped `--test-name-pattern`, source path, and source
+SHA-256. The adapter accepts evidence only when exactly one selected candidate test executes. Zero
+matches, multiple matches, a reported test name different from the bound title, malformed metadata,
+source-digest mismatch, syntax errors, generic crashes, and infrastructure failures cannot become
+attributed `ASSERTION_FAILURE` outcomes.
+
+Freeze a distinct operator plan before building:
+
+```json
+{
+  "schemaVersion": "1.0.0",
+  "campaignId": "assertledger-self-hosted-core-existing-tests-v1",
+  "repositoryRoot": "E:\\testforge",
+  "sourceTestCount": 36,
+  "targetIds": [
+    "target-dependent-gate-order",
+    "target-threshold-strict-greater",
+    "target-stability-completeness-only",
+    "target-duration-in-decision-digest"
+  ],
+  "requiredAttempts": 2,
+  "minimumTargetWeightPermille": 250,
+  "maximumSelectedCandidates": 36
+}
+```
+
+```text
+tsx benchmarks/self-hosted-core/existing-tests-builder.ts operator-plan.json sha256:<digest> evidence
+assertledger verify evidence/request.json --allow-unsafe-execution --json > evidence/manifest.json
+assertledger replay evidence/manifest.json --json
+```
+
+This request contains 36 candidates, six worlds, two attempts, and an exact maximum of 444
+executions. The selection ceiling permits every independently useful existing test to survive the
+deterministic set-cover selection if it passes every required gate. The 250-permille threshold records
+one-of-four strength, but does not override the stricter required-target rule: because all four target
+worlds are required, a candidate is eligible only when it kills all four. A replay-valid `REJECTED`
+manifest is therefore an expected and useful inventory result when the current suite has partial but
+no complete mutation coverage. See [`RESULT-existing-tests-v1.md`](RESULT-existing-tests-v1.md) for
+the first measured output. As with the original campaign, `trusted-local` is explicitly unsandboxed
+and the host-bound adapter remains inside the trusted computing base.

package/benchmarks/self-hosted-core/adapter.mjs

@@ -0,0 +1,293 @@
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { lstat, mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { NODE_TEST_REPORTER_SOURCE } from "../../dist/engine/node-test-reporter.js";
+
+const SELECTED_TEST_REPORTER_SOURCE = String.raw`
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+function normalizeFile(value) {
+  if (typeof value !== "string" || value.length === 0) return undefined;
+  let file = value;
+  if (file.startsWith("file:")) {
+    try { file = fileURLToPath(file); } catch { return undefined; }
+  }
+  const normalized = path.normalize(path.resolve(file));
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+
+function errorChainHas(error, predicate) {
+  const seen = new Set();
+  let current = error;
+  for (let depth = 0; depth < 16 && current && typeof current === "object"; depth += 1) {
+    if (seen.has(current)) break;
+    seen.add(current);
+    if (predicate(current)) return true;
+    current = current.cause;
+  }
+  return false;
+}
+
+const candidateFile = normalizeFile(process.env.TESTFORGE_SELECTED_TEST_FILE);
+
+export default async function* selectedTestReporter(source) {
+  let testsDiscovered = 0;
+  let candidateTestsDiscovered = 0;
+  let candidateFailureCount = 0;
+  let nonCandidateFailureCount = 0;
+  let candidateSyntaxFailureCount = 0;
+  let candidateFailuresAllAssertions = true;
+  const candidateTestNames = [];
+
+  for await (const event of source) {
+    const data = event && typeof event === "object" ? event.data : undefined;
+    const file = normalizeFile(data?.file);
+    const selectedFile = file !== undefined && file === candidateFile;
+    const fileWrapper = file !== undefined && normalizeFile(data?.name) === file;
+    const skipped = data?.details?.skip !== undefined && data.details.skip !== false;
+
+    if (
+      (event?.type === "test:pass" || event?.type === "test:fail") &&
+      data?.details?.type === "test" &&
+      !fileWrapper &&
+      !skipped
+    ) {
+      testsDiscovered += 1;
+      if (selectedFile) {
+        candidateTestsDiscovered += 1;
+        candidateTestNames.push(String(data?.name));
+      }
+    }
+
+    if (event?.type !== "test:fail") continue;
+    if (!fileWrapper && data?.details?.type !== "test") continue;
+    if (!selectedFile) {
+      if (!skipped) nonCandidateFailureCount += 1;
+      continue;
+    }
+    if (fileWrapper) {
+      candidateFailureCount += 1;
+    } else if (!skipped) {
+      candidateFailureCount += 1;
+    } else {
+      continue;
+    }
+    const error = data?.details?.error;
+    const assertion = errorChainHas(error, (item) => item.code === "ERR_ASSERTION");
+    const syntax = errorChainHas(error, (item) => item.name === "SyntaxError");
+    if (!assertion) candidateFailuresAllAssertions = false;
+    if (syntax) candidateSyntaxFailureCount += 1;
+  }
+
+  yield JSON.stringify({
+    protocolVersion: "1.0.0",
+    testsDiscovered,
+    candidateTestsDiscovered,
+    candidateFailureCount,
+    nonCandidateFailureCount,
+    candidateSyntaxFailureCount,
+    candidateFailuresAllAssertions,
+    candidateTestNames,
+  }) + "\n";
+}
+`;
+
+const resultFile = process.env.TESTFORGE_RESULT_FILE;
+const candidateFiles = JSON.parse(process.env.TESTFORGE_CANDIDATE_FILES ?? "[]");
+const dependencyRoot = process.argv[2];
+if (
+  typeof resultFile !== "string" ||
+  !Array.isArray(candidateFiles) ||
+  typeof dependencyRoot !== "string" ||
+  !path.isAbsolute(dependencyRoot)
+) {
+  process.exit(2);
+}
+
+function sha256Bytes(content) {
+  return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+
+function exactPattern(title) {
+  return `^${title.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`;
+}
+
+function stableCandidateId(title) {
+  return `core-it-${createHash("sha256").update(title).digest("hex").slice(0, 16)}`;
+}
+
+async function selectedTestConfiguration(files) {
+  if (files.length !== 2) return undefined;
+  const selectionFile = files.find((file) => path.basename(file) === "selection.json");
+  const sourceFile = files.find((file) => path.basename(file) === "core.test.ts");
+  if (!selectionFile || !sourceFile) return undefined;
+  let selection;
+  try {
+    selection = JSON.parse(await readFile(selectionFile, "utf8"));
+  } catch {
+    return undefined;
+  }
+  const expectedKeys = [
+    "candidateId",
+    "mode",
+    "pattern",
+    "schemaVersion",
+    "sourceDigest",
+    "sourcePath",
+    "title",
+  ];
+  if (
+    typeof selection !== "object" ||
+    selection === null ||
+    Object.keys(selection).sort().join("\0") !== expectedKeys.sort().join("\0") ||
+    selection.schemaVersion !== "1.0.0" ||
+    selection.mode !== "existing-core-test" ||
+    typeof selection.candidateId !== "string" ||
+    path.basename(path.dirname(sourceFile)) !== selection.candidateId ||
+    typeof selection.title !== "string" ||
+    typeof selection.pattern !== "string" ||
+    selection.candidateId !== stableCandidateId(selection.title) ||
+    selection.pattern !== exactPattern(selection.title) ||
+    selection.sourcePath !== "core.test.ts" ||
+    typeof selection.sourceDigest !== "string"
+  ) {
+    return undefined;
+  }
+  const source = await readFile(sourceFile);
+  if (sha256Bytes(source) !== selection.sourceDigest) return undefined;
+  return { sourceFile, pattern: selection.pattern, title: selection.title };
+}
+
+const workspaceDependencies = path.join(process.cwd(), "node_modules");
+try {
+  await lstat(workspaceDependencies);
+} catch (error) {
+  if (error?.code !== "ENOENT") throw error;
+  await symlink(
+    dependencyRoot,
+    workspaceDependencies,
+    process.platform === "win32" ? "junction" : "dir",
+  );
+}
+
+const temporaryRoot = await mkdtemp(path.join(os.tmpdir(), "assertledger-self-hosted-adapter-"));
+try {
+  const reporterPath = path.join(temporaryRoot, "node-test-reporter.mjs");
+  const reporterResultPath = path.join(temporaryRoot, "node-test-result.json");
+  const selectedTest =
+    candidateFiles.length > 0 ? await selectedTestConfiguration(candidateFiles) : undefined;
+  const selectedMode = candidateFiles.some((file) => path.basename(file) === "selection.json");
+  await writeFile(
+    reporterPath,
+    selectedMode ? SELECTED_TEST_REPORTER_SOURCE : NODE_TEST_REPORTER_SOURCE,
+    "utf8",
+  );
+  if (selectedMode && selectedTest === undefined) {
+    await writeFile(
+      resultFile,
+      JSON.stringify({
+        protocolVersion: "1.0.0",
+        outcome: "INFRA_ERROR",
+        testsDiscovered: 0,
+        candidateTestsDiscovered: 0,
+        attributed: false,
+      }),
+      "utf8",
+    );
+    process.exitCode = 1;
+  } else {
+    const testFiles =
+      candidateFiles.length === 0
+        ? ["benchmarks/self-hosted-core/liveness.test.mjs"]
+        : selectedTest
+          ? [selectedTest.sourceFile]
+          : candidateFiles;
+    const environment = {
+      ...process.env,
+      TESTFORGE_NODE_CANDIDATE_FILES: JSON.stringify(
+        (selectedTest ? [selectedTest.sourceFile] : candidateFiles).map((file) =>
+          path.resolve(file),
+        ),
+      ),
+      ...(selectedTest
+        ? { TESTFORGE_SELECTED_TEST_FILE: path.resolve(selectedTest.sourceFile) }
+        : {}),
+    };
+    const args = [
+      "--import",
+      "tsx",
+      "--test",
+      `--test-reporter=${pathToFileURL(reporterPath).href}`,
+      `--test-reporter-destination=${reporterResultPath}`,
+      ...(selectedTest ? [`--test-name-pattern=${selectedTest.pattern}`] : []),
+      "--",
+      ...testFiles,
+    ];
+    const exitCode = await new Promise((resolve, reject) => {
+      const child = spawn(process.execPath, args, {
+        cwd: process.cwd(),
+        env: environment,
+        shell: false,
+        stdio: ["ignore", "inherit", "inherit"],
+      });
+      child.once("error", reject);
+      child.once("close", (code) => resolve(code));
+    });
+    let report;
+    try {
+      report = JSON.parse(await readFile(reporterResultPath, "utf8"));
+    } catch {
+      report = undefined;
+    }
+    const candidateRun = candidateFiles.length > 0;
+    const exactCandidateCount = selectedTest
+      ? report?.testsDiscovered === 1 &&
+        report?.candidateTestsDiscovered === 1 &&
+        Array.isArray(report?.candidateTestNames) &&
+        report.candidateTestNames.length === 1 &&
+        report.candidateTestNames[0] === selectedTest.title
+      : report?.candidateTestsDiscovered >= 1;
+    const pass =
+      exitCode === 0 &&
+      report?.testsDiscovered >= 1 &&
+      report?.candidateFailureCount === 0 &&
+      report?.nonCandidateFailureCount === 0 &&
+      (!candidateRun || exactCandidateCount);
+    const attributedAssertionFailure =
+      candidateRun &&
+      exitCode !== 0 &&
+      exactCandidateCount &&
+      report?.candidateFailureCount === 1 &&
+      report?.nonCandidateFailureCount === 0 &&
+      report?.candidateSyntaxFailureCount === 0 &&
+      report?.candidateFailuresAllAssertions === true;
+    const outcome =
+      report === undefined
+        ? "INFRA_ERROR"
+        : pass
+          ? "PASS"
+          : attributedAssertionFailure
+            ? "ASSERTION_FAILURE"
+            : report.testsDiscovered === 0
+              ? "NO_TEST_DISCOVERED"
+              : "PROCESS_CRASH";
+    const structured = {
+      protocolVersion: "1.0.0",
+      outcome,
+      testsDiscovered: Number.isSafeInteger(report?.testsDiscovered) ? report.testsDiscovered : 0,
+      candidateTestsDiscovered:
+        candidateRun && Number.isSafeInteger(report?.candidateTestsDiscovered)
+          ? report.candidateTestsDiscovered
+          : 0,
+      attributed: candidateRun && (pass || attributedAssertionFailure),
+    };
+    await writeFile(resultFile, JSON.stringify(structured), "utf8");
+    process.exitCode = outcome === "PASS" ? 0 : 1;
+  }
+} finally {
+  await rm(temporaryRoot, { recursive: true, force: true });
+}

package/benchmarks/self-hosted-core/builder.ts

@@ -0,0 +1,193 @@
+import { mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseVerificationRequest } from "../../src/contracts/index.js";
+import {
+  CAMPAIGN_ID,
+  CAMPAIGN_SCHEMA_VERSION,
+  CANDIDATE_DEFINITIONS,
+  CANDIDATE_ROOT,
+  NEUTRAL_REWRITE,
+  replaceExactlyOnce,
+  sha256Bytes,
+  TARGET_MUTATIONS,
+} from "./campaign.js";
+
+interface OperatorPlan {
+  schemaVersion: "1.0.0";
+  campaignId: typeof CAMPAIGN_ID;
+  repositoryRoot: string;
+  targetIds: string[];
+  requiredAttempts: 2;
+  minimumTargetWeightPermille: 1000;
+  maximumSelectedCandidates: 4;
+}
+
+function parseOperatorPlan(value: unknown): OperatorPlan {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("INVALID_OPERATOR_PLAN");
+  }
+  const plan = value as Record<string, unknown>;
+  const keys = Object.keys(plan).sort();
+  const expected = [
+    "campaignId",
+    "maximumSelectedCandidates",
+    "minimumTargetWeightPermille",
+    "repositoryRoot",
+    "requiredAttempts",
+    "schemaVersion",
+    "targetIds",
+  ].sort();
+  const targets = TARGET_MUTATIONS.map(({ id }) => id);
+  if (
+    keys.join("\0") !== expected.join("\0") ||
+    plan.schemaVersion !== CAMPAIGN_SCHEMA_VERSION ||
+    plan.campaignId !== CAMPAIGN_ID ||
+    typeof plan.repositoryRoot !== "string" ||
+    plan.repositoryRoot.length === 0 ||
+    plan.requiredAttempts !== 2 ||
+    plan.minimumTargetWeightPermille !== 1000 ||
+    plan.maximumSelectedCandidates !== 4 ||
+    !Array.isArray(plan.targetIds) ||
+    plan.targetIds.join("\0") !== targets.join("\0")
+  ) {
+    throw new Error("INVALID_OPERATOR_PLAN");
+  }
+  return plan as unknown as OperatorPlan;
+}
+
+function stableJson(value: unknown): string {
+  const sort = (item: unknown): unknown => {
+    if (Array.isArray(item)) return item.map(sort);
+    if (typeof item !== "object" || item === null) return item;
+    return Object.fromEntries(
+      Object.entries(item)
+        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+        .map(([key, entry]) => [key, sort(entry)]),
+    );
+  };
+  return `${JSON.stringify(sort(value), null, 2)}\n`;
+}
+
+export async function buildSelfHostedCampaign(options: {
+  operatorPlanPath: string;
+  expectedOperatorPlanDigest: string;
+  outputDirectory: string;
+}): Promise<{ request: ReturnType<typeof parseVerificationRequest>; files: string[] }> {
+  const planBytes = await readFile(options.operatorPlanPath);
+  if (sha256Bytes(planBytes) !== options.expectedOperatorPlanDigest) {
+    throw new Error("OPERATOR_PLAN_DIGEST_MISMATCH");
+  }
+  const plan = parseOperatorPlan(JSON.parse(planBytes.toString("utf8")) as unknown);
+  const repositoryRoot = path.resolve(plan.repositoryRoot);
+  const dependencyRoot = await realpath(path.join(repositoryRoot, "node_modules"));
+  if (!(await stat(dependencyRoot)).isDirectory()) throw new Error("DEPENDENCY_ROOT_NOT_DIRECTORY");
+  const coreSource = await readFile(path.join(repositoryRoot, "src/core/index.ts"), "utf8");
+  const corePath = "src/core/index.ts";
+  const worlds = [
+    {
+      id: "reference",
+      kind: "REFERENCE" as const,
+      required: true,
+      weight: 0,
+      provenance: `${CAMPAIGN_ID}:reference`,
+      files: [],
+    },
+    {
+      id: NEUTRAL_REWRITE.id,
+      kind: "NEUTRAL" as const,
+      required: true,
+      weight: 0,
+      provenance: `${CAMPAIGN_ID}:${NEUTRAL_REWRITE.id}`,
+      files: [{ path: corePath, content: replaceExactlyOnce(coreSource, NEUTRAL_REWRITE) }],
+    },
+    ...TARGET_MUTATIONS.map((target) => ({
+      id: target.id,
+      kind: "TARGET" as const,
+      required: true,
+      weight: 250,
+      provenance: `${CAMPAIGN_ID}:${target.id}`,
+      files: [{ path: corePath, content: replaceExactlyOnce(coreSource, target) }],
+    })),
+  ];
+  const candidates = CANDIDATE_DEFINITIONS.map((candidate) => ({
+    id: candidate.id,
+    files: candidate.files.map((file) => ({
+      path: `${CANDIDATE_ROOT}/${candidate.id}/${file.name}`,
+      content: file.content,
+    })),
+  }));
+  const maximumExecutions = (1 + candidates.length) * worlds.length * plan.requiredAttempts;
+  const request = parseVerificationRequest({
+    schemaVersion: "1.0.0",
+    repository: {
+      root: repositoryRoot,
+      exclude: ["node_modules", ".git", "graphify-out"],
+    },
+    adapter: {
+      kind: "testforge-command",
+      executable: process.execPath,
+      arguments: ["benchmarks/self-hosted-core/adapter.mjs", dependencyRoot],
+      protocolVersion: "1.0.0",
+    },
+    isolation: {
+      kind: "trusted-local",
+      acknowledgedUnsafeExecution: true,
+      environmentAllowlist: ["PATH", "SystemRoot", "TEMP", "TMP"],
+    },
+    candidateRoots: [CANDIDATE_ROOT],
+    budgets: {
+      maximumCandidates: candidates.length,
+      maximumWorlds: worlds.length,
+      maximumExecutions,
+      maximumRepositoryFiles: 10_000,
+      maximumRepositoryBytes: 100_000_000,
+      maximumWorldOverlayBytes: 10_000_000,
+      maximumCandidateBytes: 1_000_000,
+      maximumTotalCandidateBytes: 5_000_000,
+      timeoutMsPerExecution: 30_000,
+      maximumOutputBytes: 1_000_000,
+    },
+    policy: {
+      policyVersion: "1.0.0",
+      requiredAttempts: plan.requiredAttempts,
+      minimumTargetWeightPermille: plan.minimumTargetWeightPermille,
+      maximumSelectedCandidates: plan.maximumSelectedCandidates,
+      acceptedTargetOutcomes: ["ASSERTION_FAILURE"],
+    },
+    worlds,
+    candidates,
+  });
+
+  const artifacts = new Map<string, string>();
+  artifacts.set("operator-plan.json", planBytes.toString("utf8"));
+  artifacts.set("request.json", stableJson(request));
+  artifacts.set("worlds.json", stableJson(worlds));
+  artifacts.set("candidates.json", stableJson(candidates));
+  artifacts.set(
+    "mutation-definitions.json",
+    stableJson({ neutral: NEUTRAL_REWRITE, targets: TARGET_MUTATIONS }),
+  );
+  await mkdir(options.outputDirectory, { recursive: true });
+  const files = [...artifacts.keys()].sort();
+  for (const file of files) {
+    await writeFile(
+      path.join(options.outputDirectory, file),
+      artifacts.get(file) as string,
+      "utf8",
+    );
+  }
+  return { request, files };
+}
+
+async function main(): Promise<void> {
+  const [operatorPlanPath, expectedOperatorPlanDigest, outputDirectory] = process.argv.slice(2);
+  if (!operatorPlanPath || !expectedOperatorPlanDigest || !outputDirectory) {
+    throw new Error("usage: builder.ts OPERATOR_PLAN EXPECTED_SHA256 OUTPUT_DIRECTORY");
+  }
+  await buildSelfHostedCampaign({ operatorPlanPath, expectedOperatorPlanDigest, outputDirectory });
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  await main();
+}