ts-node-pack 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-node-pack",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Pack a TypeScript package into a Node-compatible npm tarball without modifying the source tree",
   "keywords": [
     "cli",
@@ -27,12 +27,12 @@
     ".": "./src/index.js"
   },
   "dependencies": {
-    "npm-packlist": "^10.0.4",
-    "ts-blank-space": "^0.8.0"
+    "amaro": "^0.3.2",
+    "npm-packlist": "^10.0.4"
   },
   "engines": {
     "node": ">=20"
   },
-  "packageManager": "pnpm@10.33.0",
+  "packageManager": "pnpm@11.1.2",
   "types": "./src/index.d.ts"
 }

package/src/index.js

@@ -14,8 +14,9 @@ import { tmpdir } from "node:os";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { promisify } from "node:util";
 import packlist from "npm-packlist";
-import tsBlankSpace from "ts-blank-space";
-import { TS_SPECIFIER_PATTERNS, rewriteTsSpecifiers } from "./rewrite-specifiers.js";
+import { transformSync } from "amaro";
+import { rewriteTsSpecifiers } from "./rewrite-specifiers.js";
+import { validate } from "./validation.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -172,7 +173,7 @@ export async function tsNodePack(
           rootDir: packageDir,
           outDir: stagingDir,
           declaration: true,
-          // ts-blank-space handles .js emit (Phase 6); tsc only emits .d.ts.
+          // amaro handles .js emit (Phase 6); tsc only emits .d.ts.
           emitDeclarationOnly: true,
           // Extract types from JS+JSDoc sources in mixed packages.
           allowJs: true,
@@ -200,10 +201,10 @@ export async function tsNodePack(
 
     // ── Phase 6: Strip types and rewrite specifiers ─────────────────────
     // Single-pass transform of every staging file that could contain a
-    // relative module specifier: .ts/.mts get ts-blank-space'd then
+    // relative module specifier: .ts/.mts get type-stripped then
     // specifier-rewritten (one read, one write, original unlinked);
     // .js/.mjs/.d.ts/.d.mts just get specifier-rewritten in place.
-    // ts-blank-space preserves line and column positions, so no
+    // amaro preserves line and column positions, so no
     // sourcemaps are needed for debugging.
     log("Phase 6: Stripping types and rewriting specifiers...");
     const { strippedCount, rewrittenCount } = await processStagingFiles(stagingDir, log);
@@ -347,7 +348,7 @@ async function runTsc(emitConfigPath, cwd, log) {
  * changed, written once. Sourcemap files (.d.ts.map, .d.mts.map) are
  * skipped because they're binary-encoded JSON with no specifiers.
  *
- * Throws if ts-blank-space rejects a .ts/.mts file (non-erasable
+ * Throws if amaro rejects a .ts/.mts file (non-erasable
  * syntax like `enum`, `namespace`, or parameter properties).
  */
 async function processStagingFiles(stagingDir, log) {
@@ -371,16 +372,10 @@ async function processStagingFiles(stagingDir, log) {
 
     let content = source;
     if (isTs || isMts) {
-      const errors           = [];
-      content = tsBlankSpace(source, (node) => {
-        errors.push(
-          `${rel}: unsupported non-erasable syntax: ${String(node.getText?.() ?? node).slice(0, 80)}`,
-        );
-      });
-      if (errors.length > 0) {
-        throw new Error(
-          "ts-blank-space rejected non-erasable TypeScript:\n  " + errors.join("\n  "),
-        );
+      try {
+        content = transformSync(source).code;
+      } catch (err     ) {
+        throw new Error(`amaro rejected TypeScript in ${rel}:\n  ${err.message}`);
       }
     }
     content = rewriteTsSpecifiers(content);
@@ -595,7 +590,7 @@ export function rewritePackageJson(pkg) {
   } else if (result.typings) {
     result.typings = rewriteTsToDts(result.typings);
   } else if (mainWasTs) {
-    result.types = result.main.replace(/\.js$/, ".d.ts");
+    result.types = rewriteTsToDts(originalMain);
   }
 
   // Rewrite bin
@@ -617,7 +612,7 @@ export function rewritePackageJson(pkg) {
   // Rewrite files array
   if (Array.isArray(result.files)) {
     result.files = result.files.flatMap((f) => {
-      if (typeof f === "string" && /\.tsx?$/.test(f)) {
+      if (typeof f === "string" && TS_SOURCE_EXT_RE.test(f)) {
         return [rewriteTsToJs(f), rewriteTsToDts(f)];
       }
       return [f];
@@ -627,14 +622,22 @@ export function rewritePackageJson(pkg) {
   return result;
 }
 
+// `.ts`/`.tsx` → `.js`; `.mts` → `.mjs`. Matches what amaro
+// writes in Phase 6 and the specifier-rewrite pass in rewrite-specifiers.ts.
 function rewriteTsToJs(p) {
-  return typeof p === "string" ? p.replace(/\.tsx?$/, ".js") : p;
+  if (typeof p !== "string") return p;
+  return p.replace(/\.mts$/, ".mjs").replace(/\.tsx?$/, ".js");
 }
 
+// `.ts`/`.tsx` → `.d.ts`; `.mts` → `.d.mts`. Matches the declaration files
+// tsc emits from an .mts source.
 function rewriteTsToDts(p) {
-  return typeof p === "string" ? p.replace(/\.tsx?$/, ".d.ts") : p;
+  if (typeof p !== "string") return p;
+  return p.replace(/\.mts$/, ".d.mts").replace(/\.tsx?$/, ".d.ts");
 }
 
+const TS_SOURCE_EXT_RE = /\.(tsx?|mts)$/;
+
 function rewriteExportsValue(value, isTypesKey) {
   if (typeof value === "string") {
     return isTypesKey ? rewriteTsToDts(value) : rewriteTsToJs(value);
@@ -652,98 +655,6 @@ function rewriteExportsValue(value, isTypesKey) {
   return value;
 }
 
-async function validate(stagingDir, pkg, log) {
-  const errors = [];
-
-  // Check .js and .d.ts files for remaining .ts specifiers
-  const allFiles = await findFiles(
-    stagingDir,
-    (name) => name.endsWith(".js") || name.endsWith(".d.ts"),
-  );
-
-  for (const filePath of allFiles) {
-    const raw = await readFile(filePath, "utf8");
-    // Strip block and line comments before scanning so JSDoc examples that
-    // literally contain strings like `import './foo.js'` don't register as
-    // false positives. Comment stripping here is intentionally coarse
-    // (doesn't understand strings-containing-comment-markers) — good enough
-    // for tsc-emitted output, where comments are well-behaved.
-    const content = raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
-    const relPath = relative(stagingDir, filePath);
-
-    for (const pattern of TS_SPECIFIER_PATTERNS) {
-      for (const m of content.matchAll(pattern)) {
-        errors.push(`${relPath}: remaining .ts specifier: ${m[0]}`);
-      }
-    }
-  }
-
-  // Check package.json for .ts references in entry points
-  const entryFields = ["main", "module", "types", "typings"];
-  for (const field of entryFields) {
-    if (typeof pkg[field] === "string" && /(?<!\.d)\.tsx?$/.test(pkg[field])) {
-      errors.push(`package.json "${field}" still references .ts: ${pkg[field]}`);
-    }
-  }
-
-  // Non-fatal: yarn/npm tolerate `bin`/`main` pointing at missing
-  // files. Real transformation bugs are caught by the specifier
-  // checks above.
-  const referencedFiles = collectReferencedFiles(pkg);
-  for (const ref of referencedFiles) {
-    if (!existsSync(join(stagingDir, ref))) {
-      log(`  Warning: referenced file missing from tarball: ${ref}`);
-    }
-  }
-
-  if (errors.length > 0) {
-    const msg = "Validation failed:\n  " + errors.join("\n  ");
-    throw new Error(msg);
-  }
-
-  log(`Validated ${allFiles.length} file(s), no issues found`);
-}
-
-function collectReferencedFiles(pkg) {
-  const refs = new Set        ();
-
-  for (const field of ["main", "module", "types", "typings"]) {
-    if (typeof pkg[field] === "string") {
-      refs.add(pkg[field].replace(/^\.\//, ""));
-    }
-  }
-
-  if (typeof pkg.bin === "string") {
-    refs.add(pkg.bin.replace(/^\.\//, ""));
-  } else if (typeof pkg.bin === "object" && pkg.bin !== null) {
-    for (const v of Object.values(pkg.bin)) {
-      if (typeof v === "string") refs.add(v.replace(/^\.\//, ""));
-    }
-  }
-
-  if (pkg.exports) {
-    collectExportsRefs(pkg.exports, refs);
-  }
-
-  return refs;
-}
-
-function collectExportsRefs(value, refs) {
-  if (typeof value === "string") {
-    refs.add(value.replace(/^\.\//, ""));
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const v of value) collectExportsRefs(v, refs);
-    return;
-  }
-  if (typeof value === "object" && value !== null) {
-    for (const v of Object.values(value)) {
-      collectExportsRefs(v, refs);
-    }
-  }
-}
-
 async function pack(stagingDir) {
   const { stdout } = await execFileAsync("npm", ["pack"], {
     cwd: stagingDir,

package/src/rewrite-specifiers.d.ts

@@ -5,7 +5,7 @@
  * `../`) ending in `.ts`, `.tsx`, or `.mts`, embedded in one of six
  * specific syntactic contexts. The output replaces the extension with
  * `.js` (for `.ts`/`.tsx`) or `.mjs` (for `.mts`), matching what
- * `ts-blank-space` produces in the strip phase.
+ * amaro produces in the type stripping phase.
  *
  * Why regex is sound here:
  *

package/src/rewrite-specifiers.js

@@ -5,7 +5,7 @@
  * `../`) ending in `.ts`, `.tsx`, or `.mts`, embedded in one of six
  * specific syntactic contexts. The output replaces the extension with
  * `.js` (for `.ts`/`.tsx`) or `.mjs` (for `.mts`), matching what
- * `ts-blank-space` produces in the strip phase.
+ * amaro produces in the type stripping phase.
  *
  * Why regex is sound here:
  *

package/src/validation.d.ts

@@ -0,0 +1,21 @@
+export declare function validate(stagingDir: any, pkg: any, log?: (...args: unknown[]) => void): Promise<void>;
+/**
+ * Collect the relative file paths referenced by path-bearing fields of a
+ * package.json manifest, partitioned by how strictly a missing target
+ * should be treated.
+ *
+ * - `strict`: `main`, `module`, `types`, `typings`, and every leaf of
+ *   `exports`. A missing target here is a bug in the tarball we produced —
+ *   Node's module resolution will fail and `npm publish` warns on
+ *   dangling `types`.
+ * - `lenient`: `bin` entries. yarn and npm both tolerate a `bin` pointing
+ *   at a missing file (see the `bin-missing` fixture, which mirrors
+ *   agoric/portfolio-api's intentional shape).
+ *
+ * Exported for direct unit-testing of the policy; the only runtime caller
+ * is `validate()` above.
+ */
+export declare function collectReferencedFiles(pkg: any): {
+    strict: Set<string>;
+    lenient: Set<string>;
+};

package/src/validation.js

@@ -0,0 +1,142 @@
+/**
+ * Post-rewrite validation of a staged package. `validate()` is the one
+ * caller of `collectReferencedFiles`; both live here because the
+ * strict-vs-lenient partition is a policy decision owned by validation.
+ */
+import { existsSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { TS_SPECIFIER_PATTERNS } from "./rewrite-specifiers.js";
+
+export async function validate(stagingDir, pkg, log                               = () => {}) {
+  const errors = [];
+
+  // Check .js/.mjs and .d.ts/.d.mts files for remaining .ts specifiers
+  const allFiles = await findFiles(
+    stagingDir,
+    (name) =>
+      name.endsWith(".js") ||
+      name.endsWith(".mjs") ||
+      name.endsWith(".d.ts") ||
+      name.endsWith(".d.mts"),
+  );
+
+  for (const filePath of allFiles) {
+    const raw = await readFile(filePath, "utf8");
+    // Strip block and line comments before scanning so JSDoc examples that
+    // literally contain strings like `import './foo.js'` don't register as
+    // false positives. Comment stripping here is intentionally coarse
+    // (doesn't understand strings-containing-comment-markers) — good enough
+    // for tsc-emitted output, where comments are well-behaved.
+    const content = raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+    const relPath = relative(stagingDir, filePath);
+
+    for (const pattern of TS_SPECIFIER_PATTERNS) {
+      for (const m of content.matchAll(pattern)) {
+        errors.push(`${relPath}: remaining .ts specifier: ${m[0]}`);
+      }
+    }
+  }
+
+  // Check package.json for .ts references in entry points
+  const entryFields = ["main", "module", "types", "typings"];
+  for (const field of entryFields) {
+    if (typeof pkg[field] === "string" && /(?<!\.d)\.(tsx?|mts)$/.test(pkg[field])) {
+      errors.push(`package.json "${field}" still references .ts: ${pkg[field]}`);
+    }
+  }
+
+  // main/module/types/typings/exports must resolve to a file that is
+  // actually in the staging dir. This catches rewrite bugs that specifier
+  // scanning can't — e.g. the @endo/ses-ava regression where a synthesized
+  // `types: ./index.d.ts` pointed at a .d.ts ts-node-pack never emitted.
+  // `bin` is deliberately excluded: yarn/npm both tolerate a missing bin
+  // target (see the bin-missing fixture — agoric/portfolio-api ships that
+  // way intentionally), so we only warn.
+  const { strict: strictRefs, lenient: lenientRefs } = collectReferencedFiles(pkg);
+  for (const ref of strictRefs) {
+    if (!existsSync(join(stagingDir, ref))) {
+      errors.push(`referenced file missing from tarball: ${ref}`);
+    }
+  }
+  for (const ref of lenientRefs) {
+    if (!existsSync(join(stagingDir, ref))) {
+      log(`  Warning: referenced file missing from tarball: ${ref}`);
+    }
+  }
+
+  if (errors.length > 0) {
+    const msg = "Validation failed:\n  " + errors.join("\n  ");
+    throw new Error(msg);
+  }
+
+  log(`Validated ${allFiles.length} file(s), no issues found`);
+}
+
+/**
+ * Collect the relative file paths referenced by path-bearing fields of a
+ * package.json manifest, partitioned by how strictly a missing target
+ * should be treated.
+ *
+ * - `strict`: `main`, `module`, `types`, `typings`, and every leaf of
+ *   `exports`. A missing target here is a bug in the tarball we produced —
+ *   Node's module resolution will fail and `npm publish` warns on
+ *   dangling `types`.
+ * - `lenient`: `bin` entries. yarn and npm both tolerate a `bin` pointing
+ *   at a missing file (see the `bin-missing` fixture, which mirrors
+ *   agoric/portfolio-api's intentional shape).
+ *
+ * Exported for direct unit-testing of the policy; the only runtime caller
+ * is `validate()` above.
+ */
+export function collectReferencedFiles(pkg) {
+  const strict = new Set        ();
+  const lenient = new Set        ();
+  const addStrict = (p) => strict.add(stripDotSlash(p));
+  const addLenient = (p) => lenient.add(stripDotSlash(p));
+
+  for (const field of ["main", "module", "types", "typings"]) {
+    if (typeof pkg[field] === "string") addStrict(pkg[field]);
+  }
+
+  if (typeof pkg.bin === "string") {
+    addLenient(pkg.bin);
+  } else if (typeof pkg.bin === "object" && pkg.bin !== null) {
+    for (const v of Object.values(pkg.bin)) {
+      if (typeof v === "string") addLenient(v);
+    }
+  }
+
+  if (pkg.exports) collectExportsRefs(pkg.exports, strict);
+
+  return { strict, lenient };
+}
+
+function collectExportsRefs(value, refs) {
+  if (typeof value === "string") {
+    refs.add(stripDotSlash(value));
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const v of value) collectExportsRefs(v, refs);
+    return;
+  }
+  if (typeof value === "object" && value !== null) {
+    for (const v of Object.values(value)) collectExportsRefs(v, refs);
+  }
+}
+
+function stripDotSlash(p) {
+  return p.replace(/^\.\//, "");
+}
+
+async function findFiles(dir, test) {
+  const results = [];
+  const entries = await readdir(dir, { withFileTypes: true, recursive: true });
+  for (const entry of entries) {
+    if (entry.isFile() && test(entry.name)) {
+      results.push(join(entry.parentPath, entry.name));
+    }
+  }
+  return results;
+}