typescript 7.0.2: SyntaxKind

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify typescript.SyntaxKind in pkg:npm/typescript@7.0.2
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/typescript@7.0.2
Demonstrate these symbols/APIs:
  - typescript.SyntaxKind
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - packageManager: npm@10.9.8
  - runtime: node@22.23.2

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:45fc42debde8450c4c4a45b43de86dd707ad1b0b31ff66353e282e0e1dcfc2d1","constraints":{"executionContext":"node"},"contract":["SyntaxKind enum defines distinct integer identifiers for tokens, keywords, literals, and AST node types","formatSyntaxKind maps numeric SyntaxKind identifiers to canonical AST node and token names","classifySyntaxKind categorizes SyntaxKind identifiers into tokens, keywords, literals, and AST node kinds","inspectNodeSyntaxKind validates AST nodes and extracts their SyntaxKind metadata and formatted names"],"goal":"verify typescript.SyntaxKind in pkg:npm/typescript@7.0.2","kind":"HOW","packages":["pkg:npm/typescript@7.0.2"],"schemaVersion":1,"symbols":["typescript.SyntaxKind"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"cjs","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/typescript@7.0.2"],"schemaVersion":1,"subject":"pkg:npm/typescript@7.0.2","symbols":["typescript.SyntaxKind"],"verifierAdapter":"node-typescript@1"}

{
  "name": "typescript-syntax-kind-sample",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "typescript-syntax-kind-sample",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "typescript": "7.0.2"
      }
    },
    "node_modules/@typescript/typescript-aix-ppc64": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-aix-ppc64/-/typescript-aix-ppc64-7.0.2.tgz",
      "integrity": "sha512-MTKKkWB7p/0E9xi1d1tHtZ5PiLkGEMIq88pK2CubZjOsLtYTLqhgIgi6zepFa+9GHZ6h05NMCkQxGKiPXMxXtQ==",
      "cpu": [
        "ppc64"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "aix"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-darwin-arm64": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-darwin-arm64/-/typescript-darwin-arm64-7.0.2.tgz",
      "integrity": "sha512-gowzar9MwS/aRWp6f3a4KUqzRjAZjOsmGNCM6LcTgXum+dBfgsBVMN+AgvOCCbguXyick6LJhpBszxMebJ8syA==",
      "cpu": [
        "arm64"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "darwin"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-darwin-x64": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-darwin-x64/-/typescript-darwin-x64-7.0.2.tgz",
      "integrity": "sha512-SZ9xZInqApNlNGc9s0W1VSsktYSOe9cFqNOIqmN1Gs8SmkjKZYFt017G4VwPxASInODuAdbTW7sXiFUf893RgA==",
      "cpu": [
        "x64"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "darwin"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-freebsd-arm64": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-freebsd-arm64/-/typescript-freebsd-arm64-7.0.2.tgz",
      "integrity": "sha512-W5NH4y/J0plIIS5b2xvTEkU7JFxyqdMAOgf+Ilhl0vHQXKO5dZoxd+C/jEtq56c4F3wk71RB4BMRQ2XdI+bwYQ==",
      "cpu": [
        "arm64"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "freebsd"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-freebsd-x64": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-freebsd-x64/-/typescript-freebsd-x64-7.0.2.tgz",
      "integrity": "sha512-UMGDx5sTpzNw3WiPebH7l90IWfJggEd+egHt/q6p7/Cm3zqoV7VxkGXt+3DxPIw8CcmvAB0j3sVVfbhX+M4Tpw==",
      "cpu": [
        "x64"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "freebsd"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-linux-arm": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-arm/-/typescript-linux-arm-7.0.2.tgz",
      "integrity": "sha512-gffT3xPz9sR7j/YJExkyPntrI0P2EP9XbOyWzth2/Gs0RstK+90RBcO0ncXoXy/beYll1SXw846Nf2zdnEz0QQ==",
      "cpu": [
        "arm"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "linux"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-linux-arm64": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-arm64/-/typescript-linux-arm64-7.0.2.tgz",
      "integrity": "sha512-Qh4eU4/y3yDjnfjjyPYihMj5/ODIlmt+Bzu17OI+fiSRDW57QmU5SiN63exPRNJPKUzcc1INa1NXdrJ+MqHjUQ==",
      "cpu": [
        "arm64"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "linux"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-linux-loong64": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-loong64/-/typescript-linux-loong64-7.0.2.tgz",
      "integrity": "sha512-uEHck9i8hoAzXPiYRib1O7miOnz23SxIeVl6F4LXox+qov1K35jHcEW6VHKvZI+pyvl7fZEP4MCU5LYvIq1GuQ==",
      "cpu": [
        "loong64"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "linux"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-linux-mips64el": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-mips64el/-/typescript-linux-mips64el-7.0.2.tgz",
      "integrity": "sha512-R4KvAMnE43W5Qeqb0Ly56O3mWMWIAgsMyz36DCaycd5nbg/9kzm0liw3JocfRqyJY0KPmzFjbswozXyW0DnIYA==",
      "cpu": [
        "mips64el"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "linux"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-linux-ppc64": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-ppc64/-/typescript-linux-ppc64-7.0.2.tgz",
      "integrity": "sha512-DORx5b3sd/4S7eayxm4FQv+A7CrkUIGRaHiwI8oiHTAI1fAPWhF4J0vAlkC8biAlHSVVwxMQ3tjZ2/DVbnQiiA==",
      "cpu": [
        "ppc64"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "linux"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-linux-riscv64": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-riscv64/-/typescript-linux-riscv64-7.0.2.tgz",
      "integrity": "sha512-wf0jqEDOjrPRnKwYRyyJDRo11KMbvMFrU+q4zqKyChODBzvlkbhNQfKvLxQCcwTpdDaXSHZTVuh0JoCrKCUMHQ==",
      "cpu": [
        "riscv64"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "linux"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-linux-s390x": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-s390x/-/typescript-linux-s390x-7.0.2.tgz",
      "integrity": "sha512-IkwJc3L7yhytWd/ewjyxNDfOmswCm9GWMJT/ue/dU4aZNbwZeYAetq42VyLmsmSjvoX7z74X6ZaYCtzAr0EuGw==",
      "cpu": [
        "s390x"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "linux"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-linux-x64": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-x64/-/typescript-linux-x64-7.0.2.tgz",
      "integrity": "sha512-EYdf2cNg7rgCWJnxCdJ+F3V39O8ihb37eHAu1LK8oAFizgTQbPOK7zHHXbPt8rX24COqODXeI3sIf0fCXG7H/A==",
      "cpu": [
        "x64"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "linux"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-netbsd-arm64": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-netbsd-arm64/-/typescript-netbsd-arm64-7.0.2.tgz",
      "integrity": "sha512-+polYF4MF04aPpO5FTkHran9yUQDSXqy5GiSDKpsll5jy3l3+g9QLhpf39T+ePtefhXLOGrLl0QIjkQP6VnelA==",
      "cpu": [
        "arm64"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "netbsd"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-netbsd-x64": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-netbsd-x64/-/typescript-netbsd-x64-7.0.2.tgz",
      "integrity": "sha512-8YIT0EHM/3dq10ZOVF/A7pc/YSMtbcecct4rWtexrnSCHOPcpC2KTLXfTCR6vDpnSiY12heNb1GiN/wu+T/FyA==",
      "cpu": [
        "x64"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "netbsd"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-openbsd-arm64": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-openbsd-arm64/-/typescript-openbsd-arm64-7.0.2.tgz",
      "integrity": "sha512-APT8+ClYnuYm1u9+kgGXoMj2VzWzcymwh2gNSQVySHfkRDGOTVkoWLjCmOQSaO+PoqQ57B0flRp9SA+7GnnkzQ==",
      "cpu": [
        "arm64"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "openbsd"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-openbsd-x64": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-openbsd-x64/-/typescript-openbsd-x64-7.0.2.tgz",
      "integrity": "sha512-yX7s+Q0Dln0Dt9tEzZsAjXXR/+ytBM7AlglaqyeMPxQszJ1JhlJdZ6jLA+IzldHtflX81em7lDao1xXu+aRRkg==",
      "cpu": [
        "x64"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "openbsd"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-sunos-x64": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-sunos-x64/-/typescript-sunos-x64-7.0.2.tgz",
      "integrity": "sha512-dLJDGaLZ1D4HPQn62u1n8mBDkJREwMsAkCdkwd4Ieqw+x3TUyTsqY0YiBCtE6H6OzzgGk3iuZ3vFWRS+E8/d1g==",
      "cpu": [
        "x64"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "sunos"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-win32-arm64": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-win32-arm64/-/typescript-win32-arm64-7.0.2.tgz",
      "integrity": "sha512-Gyl1Vy6OsWesLzmq+EP0Fb7b4Nid5232AvcA2SFcdYreldpNtYFFofPjnt62y9hQy7VTaZp65ICJjuAQRaVcIQ==",
      "cpu": [
        "arm64"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "win32"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/@typescript/typescript-win32-x64": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/@typescript/typescript-win32-x64/-/typescript-win32-x64-7.0.2.tgz",
      "integrity": "sha512-0BQ3HkAHHlKLSp1qRvf3SUhGpGsDuhB/jgFw75guyqbxJqEaS0Cw/VFO8i2nHglJUzQCRtMMR/IBAKE3ETMC4g==",
      "cpu": [
        "x64"
      ],
      "license": "Apache-2.0",
      "optional": true,
      "os": [
        "win32"
      ],
      "engines": {
        "node": ">=16.20.0"
      }
    },
    "node_modules/typescript": {
      "version": "7.0.2",
      "resolved": "https://registry.npmjs.org/typescript/-/typescript-7.0.2.tgz",
      "integrity": "sha512-8FYau96o3NKOhbjKi/qNvG/W5jhzxkbdm5sj9AbZ/5T5sWqn3hJgLfGx27sRKZWTvyzCP8dLRBTf5tBTSRVUNA==",
      "license": "Apache-2.0",
      "bin": {
        "tsc": "bin/tsc"
      },
      "engines": {
        "node": ">=16.20.0"
      },
      "optionalDependencies": {
        "@typescript/typescript-aix-ppc64": "7.0.2",
        "@typescript/typescript-darwin-arm64": "7.0.2",
        "@typescript/typescript-darwin-x64": "7.0.2",
        "@typescript/typescript-freebsd-arm64": "7.0.2",
        "@typescript/typescript-freebsd-x64": "7.0.2",
        "@typescript/typescript-linux-arm": "7.0.2",
        "@typescript/typescript-linux-arm64": "7.0.2",
        "@typescript/typescript-linux-loong64": "7.0.2",
        "@typescript/typescript-linux-mips64el": "7.0.2",
        "@typescript/typescript-linux-ppc64": "7.0.2",
        "@typescript/typescript-linux-riscv64": "7.0.2",
        "@typescript/typescript-linux-s390x": "7.0.2",
        "@typescript/typescript-linux-x64": "7.0.2",
        "@typescript/typescript-netbsd-arm64": "7.0.2",
        "@typescript/typescript-netbsd-x64": "7.0.2",
        "@typescript/typescript-openbsd-arm64": "7.0.2",
        "@typescript/typescript-openbsd-x64": "7.0.2",
        "@typescript/typescript-sunos-x64": "7.0.2",
        "@typescript/typescript-win32-arm64": "7.0.2",
        "@typescript/typescript-win32-x64": "7.0.2"
      }
    }
  }
}

{
  "name": "typescript-syntax-kind-sample",
  "version": "1.0.0",
  "description": "Inspect, classify, and validate TypeScript AST syntax kinds and node tokens",
  "type": "module",
  "main": "src/index.mjs",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "dependencies": {
    "typescript": "7.0.2"
  },
  "license": "MIT-0"
}

{
  "schemaVersion": 1,
  "goal": "verify typescript.SyntaxKind in pkg:npm/typescript@7.0.2",
  "kind": "HOW",
  "packages": [
    "pkg:npm/typescript@7.0.2"
  ],
  "symbols": [
    "typescript.SyntaxKind"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

import {
  SyntaxKind,
  formatSyntaxKind,
  isIdentifier,
  isToken,
  isBinaryExpression,
  isVariableStatement,
  isStringLiteral,
  isNumericLiteral,
} from 'typescript/unstable/ast';

import {
  createIdentifier,
  createNumericLiteral,
  createStringLiteral,
  createToken,
  createBinaryExpression,
  createVariableDeclaration,
  createVariableDeclarationList,
  createVariableStatement,
} from 'typescript/unstable/ast/factory';

/**
 * Checks whether a given value is a valid SyntaxKind enum number.
 *
 * @param {unknown} kind
 * @returns {boolean}
 */
export function isSyntaxKind(kind) {
  return typeof kind === 'number' && Number.isInteger(kind) && typeof SyntaxKind[kind] === 'string';
}

/**
 * Returns the canonical name for a given SyntaxKind value.
 *
 * @param {number} kind
 * @returns {string}
 */
export function getSyntaxKindName(kind) {
  if (!isSyntaxKind(kind)) {
    throw new TypeError(`Invalid SyntaxKind value: ${kind}`);
  }
  return formatSyntaxKind(kind);
}

/**
 * Classifies a SyntaxKind value into categories (token, keyword, literal, node).
 *
 * @param {number} kind
 * @returns {{
 *   kind: number,
 *   name: string,
 *   category: 'token' | 'keyword' | 'literal' | 'node',
 *   isKeyword: boolean,
 *   isLiteral: boolean,
 *   isNode: boolean,
 *   isToken: boolean
 * }}
 */
export function classifySyntaxKind(kind) {
  if (!isSyntaxKind(kind)) {
    throw new TypeError(`Invalid SyntaxKind value: ${kind}`);
  }

  const isKeyword = kind >= SyntaxKind.FirstKeyword && kind <= SyntaxKind.LastKeyword;
  const isLiteral = (
    kind === SyntaxKind.NumericLiteral ||
    kind === SyntaxKind.BigIntLiteral ||
    kind === SyntaxKind.StringLiteral ||
    kind === SyntaxKind.RegularExpressionLiteral ||
    kind === SyntaxKind.NoSubstitutionTemplateLiteral
  );
  const isToken = kind >= SyntaxKind.FirstToken && kind <= SyntaxKind.LastToken;
  const isNode = kind >= SyntaxKind.FirstNode;

  let category = 'node';
  if (isKeyword) {
    category = 'keyword';
  } else if (isLiteral) {
    category = 'literal';
  } else if (isToken) {
    category = 'token';
  }

  return {
    kind,
    name: formatSyntaxKind(kind),
    category,
    isKeyword,
    isLiteral,
    isNode,
    isToken,
  };
}

/**
 * Inspects an AST node or token and returns its SyntaxKind metadata.
 *
 * @param {object} node
 * @returns {{
 *   kind: number,
 *   kindName: string,
 *   isNode: boolean,
 *   isToken: boolean
 * }}
 */
export function inspectNodeSyntaxKind(node) {
  if (!node || typeof node !== 'object' || typeof node.kind !== 'number') {
    throw new TypeError('Expected an AST node object with a numeric kind property');
  }

  const kind = node.kind;
  if (!isSyntaxKind(kind)) {
    throw new TypeError(`Node kind is not a valid SyntaxKind: ${kind}`);
  }

  const isNode = kind >= SyntaxKind.FirstNode;
  const isToken = kind >= SyntaxKind.FirstToken && kind <= SyntaxKind.LastToken;

  return {
    kind,
    kindName: formatSyntaxKind(kind),
    isNode,
    isToken,
  };
}

/**
 * Builds a binary expression AST node and validates its SyntaxKind structure.
 *
 * @param {string} leftName
 * @param {number} operatorKind
 * @param {number|string} rightValue
 * @returns {object} BinaryExpression AST node
 */
export function buildBinaryExpressionAST(leftName, operatorKind, rightValue) {
  if (typeof leftName !== 'string' || !leftName) {
    throw new TypeError('leftName must be a non-empty string');
  }
  if (!isSyntaxKind(operatorKind)) {
    throw new TypeError(`operatorKind must be a valid SyntaxKind, got: ${operatorKind}`);
  }

  const leftNode = createIdentifier(leftName);
  const operatorToken = createToken(operatorKind);
  let rightNode;
  if (typeof rightValue === 'number') {
    rightNode = createNumericLiteral(String(rightValue));
  } else if (typeof rightValue === 'string') {
    rightNode = createStringLiteral(rightValue);
  } else {
    throw new TypeError('rightValue must be a number or string');
  }

  return createBinaryExpression(undefined, leftNode, undefined, operatorToken, rightNode);
}

/**
 * Builds a variable declaration statement AST node.
 *
 * @param {string} varName
 * @param {number|string} literalValue
 * @returns {object} VariableStatement AST node
 */
export function buildVariableStatementAST(varName, literalValue) {
  if (typeof varName !== 'string' || !varName) {
    throw new TypeError('varName must be a non-empty string');
  }

  const nameNode = createIdentifier(varName);
  let initNode;
  if (typeof literalValue === 'number') {
    initNode = createNumericLiteral(String(literalValue));
  } else if (typeof literalValue === 'string') {
    initNode = createStringLiteral(literalValue);
  } else {
    throw new TypeError('literalValue must be a number or string');
  }

  const decl = createVariableDeclaration(nameNode, undefined, undefined, initNode);
  const declList = createVariableDeclarationList([decl], 0);
  return createVariableStatement(undefined, declList);
}

export {
  SyntaxKind,
  formatSyntaxKind,
  isIdentifier,
  isToken,
  isBinaryExpression,
  isVariableStatement,
  isStringLiteral,
  isNumericLiteral,
  createIdentifier,
  createNumericLiteral,
  createStringLiteral,
  createToken,
  createBinaryExpression,
  createVariableDeclaration,
  createVariableDeclarationList,
  createVariableStatement,
};

import assert from 'node:assert/strict';
import {
  SyntaxKind,
  formatSyntaxKind,
  isSyntaxKind,
  getSyntaxKindName,
  classifySyntaxKind,
  inspectNodeSyntaxKind,
  buildBinaryExpressionAST,
  buildVariableStatementAST,
  isIdentifier,
  isToken,
  isBinaryExpression,
  isVariableStatement,
  isNumericLiteral,
  isStringLiteral,
  createIdentifier,
  createNumericLiteral,
  createStringLiteral,
  createToken,
} from '../src/index.mjs';

// Contract 1: SyntaxKind enum defines distinct integer identifiers for tokens, keywords, literals, and AST node types
{
  assert.strictEqual(typeof SyntaxKind, 'object', 'SyntaxKind must be an enum object');
  assert.strictEqual(typeof SyntaxKind.Identifier, 'number', 'SyntaxKind.Identifier must be a number');
  assert.strictEqual(typeof SyntaxKind.NumericLiteral, 'number', 'SyntaxKind.NumericLiteral must be a number');
  assert.strictEqual(typeof SyntaxKind.StringLiteral, 'number', 'SyntaxKind.StringLiteral must be a number');
  assert.strictEqual(typeof SyntaxKind.PlusToken, 'number', 'SyntaxKind.PlusToken must be a number');
  assert.strictEqual(typeof SyntaxKind.SourceFile, 'number', 'SyntaxKind.SourceFile must be a number');
  assert.strictEqual(typeof SyntaxKind.FunctionDeclaration, 'number', 'SyntaxKind.FunctionDeclaration must be a number');
  assert.strictEqual(typeof SyntaxKind.VariableStatement, 'number', 'SyntaxKind.VariableStatement must be a number');

  assert.strictEqual(isSyntaxKind(SyntaxKind.Identifier), true);
  assert.strictEqual(isSyntaxKind(SyntaxKind.SourceFile), true);
  assert.strictEqual(isSyntaxKind(9999999), false);
  assert.strictEqual(isSyntaxKind('Identifier'), false);
  assert.strictEqual(isSyntaxKind(null), false);
}

// Contract 2: formatSyntaxKind maps numeric SyntaxKind identifiers to canonical AST node and token names
{
  assert.strictEqual(formatSyntaxKind(SyntaxKind.Identifier), 'Identifier');
  assert.strictEqual(formatSyntaxKind(SyntaxKind.SourceFile), 'SourceFile');
  assert.strictEqual(formatSyntaxKind(SyntaxKind.FunctionDeclaration), 'FunctionDeclaration');
  assert.strictEqual(formatSyntaxKind(SyntaxKind.BinaryExpression), 'BinaryExpression');
  assert.strictEqual(formatSyntaxKind(SyntaxKind.PlusToken), 'PlusToken');
  assert.strictEqual(formatSyntaxKind(SyntaxKind.StringLiteral), 'StringLiteral');

  assert.strictEqual(getSyntaxKindName(SyntaxKind.Identifier), 'Identifier');
  assert.strictEqual(getSyntaxKindName(SyntaxKind.VariableStatement), 'VariableStatement');
  assert.throws(() => getSyntaxKindName(-1), { name: 'TypeError' });
}

// Contract 3: classifySyntaxKind categorizes SyntaxKind identifiers into tokens, keywords, literals, and AST node kinds
{
  const idInfo = classifySyntaxKind(SyntaxKind.Identifier);
  assert.strictEqual(idInfo.name, 'Identifier');
  assert.strictEqual(idInfo.category, 'token');
  assert.strictEqual(idInfo.isToken, true);
  assert.strictEqual(idInfo.isKeyword, false);
  assert.strictEqual(idInfo.isNode, false);

  const keywordInfo = classifySyntaxKind(SyntaxKind.TrueKeyword);
  assert.strictEqual(keywordInfo.name, 'TrueKeyword');
  assert.strictEqual(keywordInfo.category, 'keyword');
  assert.strictEqual(keywordInfo.isKeyword, true);
  assert.strictEqual(keywordInfo.isToken, true);
  assert.strictEqual(keywordInfo.isNode, false);

  const litInfo = classifySyntaxKind(SyntaxKind.StringLiteral);
  assert.strictEqual(litInfo.name, 'StringLiteral');
  assert.strictEqual(litInfo.category, 'literal');
  assert.strictEqual(litInfo.isLiteral, true);
  assert.strictEqual(litInfo.isToken, true);

  const nodeInfo = classifySyntaxKind(SyntaxKind.BinaryExpression);
  assert.strictEqual(nodeInfo.name, 'BinaryExpression');
  assert.strictEqual(nodeInfo.category, 'node');
  assert.strictEqual(nodeInfo.isNode, true);
  assert.strictEqual(nodeInfo.isToken, false);

  assert.throws(() => classifySyntaxKind('invalid'), { name: 'TypeError' });
}

// Contract 4: inspectNodeSyntaxKind validates AST nodes and extracts their SyntaxKind metadata and formatted names
{
  const binNode = buildBinaryExpressionAST('total', SyntaxKind.PlusToken, 50);
  assert.strictEqual(isBinaryExpression(binNode), true);
  assert.strictEqual(binNode.kind, SyntaxKind.BinaryExpression);

  const binInspect = inspectNodeSyntaxKind(binNode);
  assert.strictEqual(binInspect.kind, SyntaxKind.BinaryExpression);
  assert.strictEqual(binInspect.kindName, 'BinaryExpression');
  assert.strictEqual(binInspect.isNode, true);

  const leftInspect = inspectNodeSyntaxKind(binNode.left);
  assert.strictEqual(leftInspect.kind, SyntaxKind.Identifier);
  assert.strictEqual(leftInspect.kindName, 'Identifier');
  assert.strictEqual(leftInspect.isToken, true);

  const opInspect = inspectNodeSyntaxKind(binNode.operatorToken);
  assert.strictEqual(opInspect.kind, SyntaxKind.PlusToken);
  assert.strictEqual(opInspect.kindName, 'PlusToken');
  assert.strictEqual(opInspect.isToken, true);

  const rightInspect = inspectNodeSyntaxKind(binNode.right);
  assert.strictEqual(rightInspect.kind, SyntaxKind.NumericLiteral);
  assert.strictEqual(rightInspect.kindName, 'NumericLiteral');

  const varStmt = buildVariableStatementAST('greeting', 'hello');
  assert.strictEqual(isVariableStatement(varStmt), true);
  const stmtInspect = inspectNodeSyntaxKind(varStmt);
  assert.strictEqual(stmtInspect.kind, SyntaxKind.VariableStatement);
  assert.strictEqual(stmtInspect.kindName, 'VariableStatement');

  assert.throws(() => inspectNodeSyntaxKind(null), { name: 'TypeError' });
  assert.throws(() => inspectNodeSyntaxKind({ kind: 'not-a-number' }), { name: 'TypeError' });
}

console.log('All typescript.SyntaxKind contract tests passed.');