@typespec/http-server-js 0.58.0-alpha.12-dev.0 → 0.58.0-alpha.12-dev.2

package/eng/scripts/emit-e2e.js

@@ -0,0 +1,315 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+import { run } from "@typespec/internal-build-utils";
+import pkg from "fs-extra";
+import { copyFile, mkdir, rm } from "fs/promises";
+import { globby } from "globby";
+import inquirer from "inquirer";
+import ora from "ora";
+import pLimit from "p-limit";
+import { basename, dirname, join, resolve } from "path";
+import pc from "picocolors";
+import { fileURLToPath } from "url";
+import { hideBin } from "yargs/helpers";
+import yargs from "yargs/yargs";
+
+const { pathExists, stat, readFile, writeFile } = pkg;
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const projectRoot = join(__dirname, "../..");
+const tspConfig = join(__dirname, "tspconfig.yaml");
+
+const basePath = join(projectRoot, "node_modules", "@typespec", "http-specs", "specs");
+const ignoreFilePath = join(projectRoot, ".testignore");
+const logDirRoot = join(projectRoot, "temp", "emit-e2e-logs");
+const reportFilePath = join(logDirRoot, "report.txt");
+
+// Remove the log directory if it exists.
+async function clearLogDirectory() {
+  if (await pathExists(logDirRoot)) {
+    await rm(logDirRoot, { recursive: true, force: true });
+  }
+}
+
+// Parse command-line arguments.
+const argv = yargs(hideBin(process.argv))
+  .option("interactive", {
+    type: "boolean",
+    describe: "Enable interactive mode",
+    default: false,
+  })
+  .positional("paths", {
+    describe: "Optional list of specific file or directory paths to process (relative to basePath)",
+    type: "string",
+    array: true,
+    default: [],
+  })
+  .option("build", {
+    type: "boolean",
+    describe: "Build the generated projects",
+    default: false,
+  })
+  .help().argv;
+
+// Read and parse the ignore file.
+async function getIgnoreList() {
+  try {
+    const content = await readFile(ignoreFilePath, "utf8");
+    return content
+      .split(/\r?\n/)
+      .filter((line) => line.trim() && !line.startsWith("#"))
+      .map((line) => line.trim());
+  } catch {
+    console.warn(pc.yellow("No ignore file found."));
+    return [];
+  }
+}
+
+// Recursively process paths (files or directories relative to basePath).
+async function processPaths(paths, ignoreList) {
+  const results = [];
+  for (const relativePath of paths) {
+    const fullPath = resolve(basePath, relativePath);
+
+    if (!(await pathExists(fullPath))) {
+      console.warn(pc.yellow(`Path not found: ${relativePath}`));
+      continue;
+    }
+
+    const stats = await stat(fullPath);
+    if (stats.isFile() && fullPath.endsWith("main.tsp")) {
+      if (ignoreList.some((ignore) => relativePath.startsWith(ignore))) continue;
+      results.push({ fullPath, relativePath });
+    } else if (stats.isDirectory()) {
+      const patterns = ["**/main.tsp"];
+      const discoveredPaths = await globby(patterns, { cwd: fullPath });
+      const validFiles = discoveredPaths
+        .map((p) => ({
+          fullPath: join(fullPath, p),
+          relativePath: join(relativePath, p),
+        }))
+        .filter((file) => !ignoreList.some((ignore) => file.relativePath.startsWith(ignore)));
+      results.push(...validFiles);
+    } else {
+      console.warn(pc.yellow(`Skipping unsupported path: ${relativePath}`));
+    }
+  }
+
+  // Deduplicate.
+  const filesByDir = new Map();
+  for (const file of results) {
+    const dir = dirname(file.relativePath);
+    const existing = filesByDir.get(dir);
+    if (!existing) {
+      filesByDir.set(dir, file);
+    }
+  }
+  return Array.from(filesByDir.values());
+}
+
+// Run a shell command silently.
+async function runCommand(command, args, options = {}) {
+  // Remove clutter by not printing anything; capture output by setting stdio to 'pipe'.
+  return await run(command, args, {
+    stdio: "pipe",
+    env: { NODE_ENV: "test", ...process.env },
+    silent: true,
+    ...options,
+  });
+}
+
+// Process a single file.
+async function processFile(file, options) {
+  const { fullPath, relativePath } = file;
+  const { build, interactive } = options;
+  const outputDir = join("test", "e2e", "generated", dirname(relativePath));
+  const specCopyPath = join(outputDir, "spec.tsp");
+  const logDir = join(projectRoot, "temp", "emit-e2e-logs", dirname(relativePath));
+
+  let spinner;
+  if (interactive) {
+    spinner = ora({ text: `Processing: ${relativePath}`, color: "cyan" }).start();
+  }
+
+  try {
+    if (await pathExists(outputDir)) {
+      if (spinner) spinner.text = `Clearing directory: ${outputDir}`;
+      await rm(outputDir, { recursive: true, force: true });
+    }
+    if (spinner) spinner.text = `Creating directory: ${outputDir}`;
+    await mkdir(outputDir, { recursive: true });
+
+    if (spinner) spinner.text = `Copying spec to: ${specCopyPath}`;
+    await copyFile(fullPath, specCopyPath);
+
+    if (spinner) spinner.text = `Compiling: ${relativePath}`;
+    await runCommand("npx", [
+      "tsp",
+      "compile",
+      fullPath,
+      "--emit",
+      resolve(import.meta.dirname, "../.."),
+      "--config",
+      tspConfig,
+      "--output-dir",
+      outputDir,
+    ]);
+
+    if (spinner) spinner.text = `Formatting with Prettier: ${relativePath}`;
+    await runCommand("npx", ["prettier", outputDir, "--write"]);
+
+    if (build) {
+      if (spinner) spinner.text = `Building project: ${relativePath}`;
+      await runCommand("npm", ["run", "build"], { cwd: outputDir });
+    }
+
+    if (spinner) {
+      spinner.succeed(`Finished processing: ${relativePath}`);
+    }
+    return { status: "succeeded", relativePath };
+  } catch (error) {
+    if (spinner) {
+      spinner.fail(`Failed processing: ${relativePath}`);
+    }
+    const errorDetails = error.stdout || error.stderr || error.message;
+
+    // Write error details to a log file.
+    await mkdir(logDir, { recursive: true });
+    const logFilePath = join(logDir, `${basename(relativePath, ".tsp")}-error.log`);
+    await writeFile(logFilePath, errorDetails, "utf8");
+
+    if (interactive) {
+      const { action } = await inquirer.prompt([
+        {
+          type: "list",
+          name: "action",
+          message: `Processing failed for ${relativePath}. What would you like to do?`,
+          choices: [
+            { name: "Retry", value: "retry" },
+            { name: "Skip to next file", value: "next" },
+            { name: "Abort processing", value: "abort" },
+          ],
+        },
+      ]);
+
+      if (action === "retry") {
+        if (spinner) spinner.start(`Retrying: ${relativePath}`);
+        return await processFile(file, options);
+      } else if (action === "next") {
+        console.log(pc.yellow(`Skipping: ${relativePath}`));
+      } else if (action === "abort") {
+        console.log(pc.red("Aborting processing."));
+        throw new Error("Processing aborted by user");
+      }
+    }
+    return { status: "failed", relativePath, errorDetails };
+  }
+}
+
+// Process all files.
+async function processFiles(files, options) {
+  const { interactive } = options;
+  const succeeded = [];
+  const failed = [];
+
+  if (interactive) {
+    // Sequential processing so each spinner is visible.
+    for (const file of files) {
+      try {
+        const result = await processFile(file, options);
+        if (result.status === "succeeded") {
+          succeeded.push(result.relativePath);
+        } else {
+          failed.push({ relativePath: result.relativePath, errorDetails: result.errorDetails });
+        }
+      } catch (err) {
+        break;
+      }
+    }
+  } else {
+    // Global progress spinner.
+    const total = files.length;
+    let completed = 0;
+    const globalSpinner = ora({ text: `Processing 0/${total} files...`, color: "cyan" }).start();
+    const limit = pLimit(4);
+    const tasks = files.map((file) =>
+      limit(() =>
+        processFile(file, options).then((result) => {
+          completed++;
+          globalSpinner.text = `Processing ${completed}/${total} files...`;
+          return result;
+        }),
+      ),
+    );
+    const results = await Promise.all(tasks);
+    globalSpinner.succeed(`Processed ${total} files`);
+    for (const result of results) {
+      if (result.status === "succeeded") {
+        succeeded.push(result.relativePath);
+      } else {
+        failed.push({ relativePath: result.relativePath, errorDetails: result.errorDetails });
+      }
+    }
+  }
+
+  console.log(pc.bold(pc.green("\nProcessing Complete:")));
+  console.log(pc.green(`Succeeded: ${succeeded.length}`));
+  console.log(pc.red(`Failed: ${failed.length}`));
+
+  if (failed.length > 0) {
+    console.log(pc.red("\nFailed Specs:"));
+    failed.forEach((f) => {
+      console.log(pc.red(`  - ${f.relativePath}`));
+    });
+    console.log(pc.blue(`\nLogs available at: ${logDirRoot}`));
+  }
+
+  // Ensure the log directory exists before writing the report.
+  await mkdir(logDirRoot, { recursive: true });
+  const report = [
+    "Succeeded Files:",
+    ...succeeded.map((f) => `  - ${f}`),
+    "Failed Files:",
+    ...failed.map((f) => `  - ${f.relativePath}\n    Error: ${f.errorDetails}`),
+  ].join("\n");
+  await writeFile(reportFilePath, report, "utf8");
+  console.log(pc.blue(`Report written to: ${reportFilePath}`));
+}
+// Main execution function
+async function main() {
+  const startTime = process.hrtime.bigint(); // ✅ High precision time tracking
+  let exitCode = 0; // ✅ Track success/failure
+
+  try {
+    await clearLogDirectory(); // ✅ Clear logs at the start
+
+    const ignoreList = await getIgnoreList();
+    const paths = argv._.length
+      ? await processPaths(argv._, ignoreList)
+      : await processPaths(["."], ignoreList);
+
+    if (paths.length === 0) {
+      console.log(pc.yellow("⚠️ No files to process."));
+      return;
+    }
+
+    await processFiles(paths, {
+      interactive: argv.interactive,
+      build: argv.build,
+    });
+  } catch (error) {
+    console.error(pc.red(`❌ Fatal Error: ${error.message}`));
+    exitCode = 1; // ✅ Ensure graceful failure handling
+  } finally {
+    // ✅ Always log execution time before exit
+    const endTime = process.hrtime.bigint();
+    const duration = Number(endTime - startTime) / 1e9; // Convert nanoseconds to seconds
+    console.log(pc.blue(`⏱️ Total execution time: ${duration.toFixed(2)} seconds`));
+
+    process.exit(exitCode); // ✅ Ensures proper exit handling
+  }
+}
+
+await main();

package/eng/scripts/tspconfig.yaml

@@ -0,0 +1,6 @@
+emitters:
+  "@typespec/http-server-js": true
+
+options:
+  "@typespec/http-server-js":
+    emitter-output-dir: "{output-dir}"

package/generated-defs/helpers/datetime.ts

@@ -0,0 +1,263 @@
+// Copyright (c) Microsoft Corporation
+// Licensed under the MIT license.
+
+import { Module } from "../../src/ctx.js";
+
+export let module: Module = undefined as any;
+
+// prettier-ignore
+const lines = [
+  "// Copyright (c) Microsoft Corporation",
+  "// Licensed under the MIT license.",
+  "",
+  "// #region Duration",
+  "",
+  "/**",
+  " * Regular expression for matching ISO8601 duration strings.",
+  " *",
+  " * Yields:",
+  " * - 0: the full match",
+  " * - 1: the sign (optional)",
+  " * - 2: years (optional)",
+  " * - 3: months (optional)",
+  " * - 4: weeks (optional)",
+  " * - 5: days (optional)",
+  " * - 6: hours (optional)",
+  " * - 7: minutes (optional)",
+  " * - 8: seconds (optional)",
+  " */",
+  "const ISO8601_DURATION_REGEX =",
+  "  /^(-)?P(?:((?:\\d*[.,])?\\d+)Y)?(?:((?:\\d*[.,])?\\d+)M)?(?:((?:\\d*[.,])?\\d+)W)?(?:((?:\\d*[.,])?\\d+)D)?(?:T(?:((?:\\d*[.,])?\\d+)H)?(?:((?:\\d*[.,])?\\d+)M)?(?:((?:\\d*[.,])?\\d+)S)?)?$/;",
+  "",
+  "/**",
+  " * A duration of time, measured in years, months, weeks, days, hours, minutes, and seconds.",
+  " *",
+  " * The values may be fractional and are not normalized (e.g. 36 hours is not the same duration as 1 day and 12 hours",
+  " * when accounting for Daylight Saving Time changes or leap seconds).",
+  " *",
+  " * @see https://en.wikipedia.org/wiki/ISO_8601#Durations",
+  " */",
+  "export interface Duration {",
+  "  /**",
+  "   * \"+\" if the duration is positive, \"-\" if the duration is negative.",
+  "   */",
+  "  sign: \"+\" | \"-\";",
+  "  /**",
+  "   * The number of years in the duration.",
+  "   */",
+  "  years: number;",
+  "  /**",
+  "   * The number of months in the duration.",
+  "   */",
+  "  months: number;",
+  "  /**",
+  "   * The number of weeks in the duration.",
+  "   */",
+  "  weeks: number;",
+  "  /**",
+  "   * The number of days in the duration.",
+  "   */",
+  "  days: number;",
+  "  /**",
+  "   * The number of hours in the duration.",
+  "   */",
+  "  hours: number;",
+  "  /**",
+  "   * The number of minutes in the duration.",
+  "   */",
+  "  minutes: number;",
+  "  /**",
+  "   * The number of seconds in the duration.",
+  "   */",
+  "  seconds: number;",
+  "}",
+  "",
+  "export const Duration = Object.freeze({",
+  "  /**",
+  "   * Parses an ISO8601 duration string into an object.",
+  "   *",
+  "   * @see https://en.wikipedia.org/wiki/ISO_8601#Durations",
+  "   *",
+  "   * @param duration - the duration string to parse",
+  "   * @returns an object containing the parsed duration",
+  "   */",
+  "  parseISO8601(duration: string, maxLength: number = 100): Duration {",
+  "    duration = duration.trim();",
+  "    if (duration.length > maxLength)",
+  "      throw new Error(`ISO8601 duration string is too long: ${duration}`);",
+  "",
+  "    const match = duration.match(ISO8601_DURATION_REGEX);",
+  "",
+  "    if (!match) throw new Error(`Invalid ISO8601 duration: ${duration}`);",
+  "",
+  "    return {",
+  "      sign: match[1] === undefined ? \"+\" : (match[1] as Duration[\"sign\"]),",
+  "      years: parseFloatNormal(match[2]),",
+  "      months: parseFloatNormal(match[3]),",
+  "      weeks: parseFloatNormal(match[4]),",
+  "      days: parseFloatNormal(match[5]),",
+  "      hours: parseFloatNormal(match[6]),",
+  "      minutes: parseFloatNormal(match[7]),",
+  "      seconds: parseFloatNormal(match[8]),",
+  "    };",
+  "",
+  "    function parseFloatNormal(match: string | undefined): number {",
+  "      if (match === undefined) return 0;",
+  "",
+  "      const normalized = match.replace(\",\", \".\");",
+  "",
+  "      const parsed = parseFloat(normalized);",
+  "",
+  "      if (isNaN(parsed))",
+  "        throw new Error(`Unreachable: Invalid number in ISO8601 duration string: ${match}`);",
+  "",
+  "      return parsed;",
+  "    }",
+  "  },",
+  "  /**",
+  "   * Writes a Duration to an ISO8601 duration string.",
+  "   *",
+  "   * @see https://en.wikipedia.org/wiki/ISO_8601#Durations",
+  "   *",
+  "   * @param duration - the duration to write to a string",
+  "   * @returns a string in ISO8601 duration format",
+  "   */",
+  "  toISO8601(duration: Duration): string {",
+  "    const sign = duration.sign === \"+\" ? \"\" : \"-\";",
+  "",
+  "    const years =",
+  "      duration.years !== 0 && !isNaN(Number(duration.years)) ? `${duration.years}Y` : \"\";",
+  "    const months =",
+  "      duration.months !== 0 && !isNaN(Number(duration.months)) ? `${duration.months}M` : \"\";",
+  "    const weeks =",
+  "      duration.weeks !== 0 && !isNaN(Number(duration.weeks)) ? `${duration.weeks}W` : \"\";",
+  "    const days = duration.days !== 0 && !isNaN(Number(duration.days)) ? `${duration.days}D` : \"\";",
+  "",
+  "    let time = \"\";",
+  "",
+  "    const _hours = duration.hours !== 0 && !isNaN(Number(duration.hours));",
+  "    const _minutes = duration.minutes !== 0 && !isNaN(Number(duration.minutes));",
+  "    const _seconds = duration.seconds !== 0 && !isNaN(Number(duration.seconds));",
+  "",
+  "    if (_hours || _minutes || _seconds) {",
+  "      const hours = _hours ? `${duration.hours}H` : \"\";",
+  "      const minutes = _minutes ? `${duration.minutes}M` : \"\";",
+  "      const seconds = _seconds ? `${duration.seconds}S` : \"\";",
+  "",
+  "      time = `T${hours}${minutes}${seconds}`;",
+  "    }",
+  "",
+  "    return `${sign}P${years}${months}${weeks}${days}${time}`;",
+  "  },",
+  "",
+  "  /**",
+  "   * Gets the total number of seconds in a duration.",
+  "   *",
+  "   * This method will throw an Error if the duration contains any years, months, weeks, or days, as those require a reference",
+  "   * point to calculate the total number of seconds.",
+  "   *",
+  "   * WARNING: If the total number of seconds is larger than the maximum safe integer in JavaScript, this method will",
+  "   * lose precision. @see Duration.totalSecondsBigInt for a BigInt alternative.",
+  "   *",
+  "   * @param duration - the duration to calculate the total number of seconds for",
+  "   * @returns the total number of seconds in the duration",
+  "   */",
+  "  totalSeconds(duration: Duration): number {",
+  "    if (",
+  "      duration.years !== 0 ||",
+  "      duration.months !== 0 ||",
+  "      duration.weeks !== 0 ||",
+  "      duration.days !== 0",
+  "    ) {",
+  "      throw new Error(",
+  "        \"Cannot calculate total seconds for a duration with years, months, weeks, or days.\",",
+  "      );",
+  "    }",
+  "",
+  "    return (",
+  "      duration.seconds +",
+  "      duration.minutes * 60 +",
+  "      duration.hours * 60 * 60 +",
+  "      duration.weeks * 7 * 24 * 60 * 60",
+  "    );",
+  "  },",
+  "",
+  "  /**",
+  "   * Gets the total number of seconds in a duration.",
+  "   *",
+  "   * This method will throw an Error if the duration contains any years, months, weeks, or days, as those require a reference",
+  "   * point to calculate the total number of seconds. It will also throw an error if any of the components are not integers.",
+  "   *",
+  "   * @param duration - the duration to calculate the total number of seconds for",
+  "   * @returns the total number of seconds in the duration",
+  "   */",
+  "  totalSecondsBigInt(duration: Duration): bigint {",
+  "    if (",
+  "      duration.years !== 0 ||",
+  "      duration.months !== 0 ||",
+  "      duration.weeks !== 0 ||",
+  "      duration.days !== 0",
+  "    ) {",
+  "      throw new Error(",
+  "        \"Cannot calculate total seconds for a duration with years, months, weeks, or days.\",",
+  "      );",
+  "    }",
+  "",
+  "    if (",
+  "      !Number.isInteger(duration.seconds) ||",
+  "      !Number.isInteger(duration.minutes) ||",
+  "      !Number.isInteger(duration.hours) ||",
+  "      !Number.isInteger(duration.weeks)",
+  "    ) {",
+  "      throw new Error(",
+  "        \"Cannot calculate total seconds as a BigInt for a duration with non-integer components.\",",
+  "      );",
+  "    }",
+  "",
+  "    return (",
+  "      BigInt(duration.seconds) +",
+  "      BigInt(duration.minutes) * 60n +",
+  "      BigInt(duration.hours) * 60n * 60n +",
+  "      BigInt(duration.weeks) * 7n * 24n * 60n * 60n",
+  "    );",
+  "  },",
+  "",
+  "  /**",
+  "   * Creates a duration from a total number of seconds.",
+  "   *",
+  "   * The result is not normalized, so it will only contain a seconds field.",
+  "   */",
+  "  fromTotalSeconds(seconds: number): Duration {",
+  "    return {",
+  "      sign: seconds < 0 ? \"-\" : \"+\",",
+  "      years: 0,",
+  "      months: 0,",
+  "      weeks: 0,",
+  "      days: 0,",
+  "      hours: 0,",
+  "      minutes: 0,",
+  "      seconds: Math.abs(seconds),",
+  "    };",
+  "  },",
+  "});",
+  "",
+  "// #endregion",
+  "",
+];
+
+export async function createModule(parent: Module): Promise<Module> {
+  if (module) return module;
+
+  module = {
+    name: "datetime",
+    cursor: parent.cursor.enter("datetime"),
+    imports: [],
+    declarations: [],
+  };
+
+  module.declarations.push(lines);
+
+  parent.declarations.push(module);
+
+  return module;
+}

package/generated-defs/helpers/index.ts

@@ -16,6 +16,7 @@ export async function createModule(parent: Module): Promise<Module> {
   };
 
   // Child modules
+  await import("./datetime.js").then((m) => m.createModule(module));
   await import("./header.js").then((m) => m.createModule(module));
   await import("./http.js").then((m) => m.createModule(module));
   await import("./multipart.js").then((m) => m.createModule(module));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/http-server-js",
-  "version": "0.58.0-alpha.12-dev.0",
+  "version": "0.58.0-alpha.12-dev.2",
   "author": "Microsoft Corporation",
   "description": "TypeSpec HTTP server code generator for JavaScript",
   "homepage": "https://github.com/microsoft/typespec",
@@ -30,9 +30,9 @@
     "hsj-scaffold": "./dist/src/scripts/scaffold/bin.mjs"
   },
   "peerDependencies": {
-    "@typespec/compiler": "^0.67.0 || >=0.68.0-dev <0.68.0",
-    "@typespec/http": "^0.67.0 || >=0.68.0-dev <0.68.0",
-    "@typespec/openapi3": "^0.67.0 || >=0.68.0-dev <0.68.0"
+    "@typespec/compiler": "^0.67.1 || >=0.68.0-dev <0.68.0",
+    "@typespec/http": "^0.67.1 || >=0.68.0-dev <0.68.0",
+    "@typespec/openapi3": "^0.67.1 || >=0.68.0-dev <0.68.0"
   },
   "peerDependenciesMeta": {
     "@typespec/openapi3": {
@@ -45,14 +45,25 @@
   },
   "devDependencies": {
     "@types/node": "~22.13.9",
-    "@typespec/compiler": "^0.67.0 || >=0.68.0-dev <0.68.0",
-    "@typespec/http": "^0.67.0 || >=0.68.0-dev <0.68.0",
-    "@typespec/openapi3": "^0.67.0 || >=0.68.0-dev <0.68.0",
+    "@typespec/compiler": "^0.67.1 || >=0.68.0-dev <0.68.0",
+    "@typespec/http": "^0.67.1 || >=0.68.0-dev <0.68.0",
+    "@typespec/http-specs": "^0.1.0-alpha.15 || >=0.1.0-alpha.16-dev <0.1.0-alpha.16",
+    "@typespec/internal-build-utils": "^0.67.1 || >=0.68.0-dev <0.68.0",
+    "@typespec/openapi3": "^0.67.1 || >=0.68.0-dev <0.68.0",
+    "@typespec/spector": "^0.1.0-alpha.9 || >=0.1.0-alpha.10-dev <0.1.0-alpha.10",
     "@vitest/coverage-v8": "^3.0.7",
     "@vitest/ui": "^3.0.7",
+    "fs-extra": "^11.2.0",
+    "globby": "~14.1.0",
+    "inquirer": "^12.2.0",
+    "ora": "^8.1.1",
+    "p-limit": "^6.2.0",
+    "pathe": "^2.0.3",
+    "picocolors": "~1.1.1",
     "tsx": "^4.19.3",
     "typescript": "~5.8.2",
-    "vitest": "^3.0.7"
+    "vitest": "^3.0.7",
+    "yargs": "~17.7.2"
   },
   "scripts": {
     "clean": "rimraf ./dist ./temp",
@@ -66,6 +77,9 @@
     "test:ci": "vitest run --coverage --reporter=junit --reporter=default",
     "lint": "eslint . --max-warnings=0",
     "lint:fix": "eslint . --fix",
-    "regen-docs": "echo Doc generation disabled for this package."
+    "regen-docs": "echo Doc generation disabled for this package.",
+    "test:e2e": "npm run emit:e2e && npm run run:e2e",
+    "emit:e2e": "node eng/scripts/emit-e2e.js",
+    "run:e2e": "vitest run --config ./vitest.config.e2e.js"
   }
 }

package/src/common/declaration.ts

@@ -42,7 +42,7 @@ export function* emitDeclaration(
       break;
     }
     case "Scalar": {
-      yield emitScalar(ctx, type);
+      yield emitScalar(ctx, type, module);
       break;
     }
     default: {

package/src/common/reference.ts

@@ -70,7 +70,7 @@ export function emitTypeReference(
   switch (type.kind) {
     case "Scalar":
       // Get the scalar and return it directly, as it is a primitive.
-      return getJsScalar(ctx.program, type, position);
+      return getJsScalar(ctx, module, type, position).type;
     case "Model": {
       // First handle arrays.
       if (isArrayModelType(ctx.program, type)) {