@git.zone/tstest 3.1.8 → 3.3.0

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/tstest',
-  version: '3.1.8',
-  description: 'a test utility to run tests that match test/**/*.ts'
+  version: '3.3.0',
+  description: 'A powerful, modern test runner for TypeScript with multi-runtime support (Node.js, Deno, Bun, Chromium) and a batteries-included test framework.'
 }

package/ts/tstest.classes.migration.ts

@@ -111,10 +111,7 @@ export class Migration {
    * Find all legacy test files in the base directory
    */
   async findLegacyFiles(): Promise<string[]> {
-    const files = await plugins.smartfile.fs.listFileTree(
-      this.options.baseDir,
-      this.options.pattern
-    );
+    const files = plugins.fs.globSync(this.options.pattern, { cwd: this.options.baseDir }) as string[];
 
     const legacyFiles: string[] = [];
 
@@ -154,7 +151,7 @@ export class Migration {
       const newPath = plugins.path.join(dirName, newFileName);
 
       // Check if target file already exists
-      if (await plugins.smartfile.fs.fileExists(newPath)) {
+      if (await plugins.smartfsInstance.file(newPath).exists()) {
         return {
           oldPath: filePath,
           newPath,
@@ -206,7 +203,7 @@ export class Migration {
   private async isGitRepository(dir: string): Promise<boolean> {
     try {
       const gitDir = plugins.path.join(dir, '.git');
-      return await plugins.smartfile.fs.isDirectory(gitDir);
+      return await plugins.smartfsInstance.directory(gitDir).exists();
     } catch {
       return false;
     }

package/ts/tstest.classes.runtime.bun.ts

@@ -121,7 +121,7 @@ export class BunRuntimeAdapter extends RuntimeAdapter {
     // Check for 00init.ts file in test directory
     const testDir = plugins.path.dirname(testFile);
     const initFile = plugins.path.join(testDir, '00init.ts');
-    const initFileExists = await plugins.smartfile.fs.fileExists(initFile);
+    const initFileExists = await plugins.smartfsInstance.file(initFile).exists();
 
     let runCommand = fullCommand;
     let loaderPath: string | null = null;
@@ -135,7 +135,7 @@ import '${absoluteInitFile.replace(/\\/g, '/')}';
 import '${absoluteTestFile.replace(/\\/g, '/')}';
 `;
       loaderPath = plugins.path.join(testDir, `.loader_${plugins.path.basename(testFile)}`);
-      await plugins.smartfile.memory.toFs(loaderContent, loaderPath);
+      await plugins.smartfsInstance.file(loaderPath).write(loaderContent);
 
       // Rebuild command with loader file
       const loaderCommand = this.createCommand(loaderPath, mergedOptions);
@@ -148,8 +148,8 @@ import '${absoluteTestFile.replace(/\\/g, '/')}';
     if (loaderPath) {
       const cleanup = () => {
         try {
-          if (plugins.smartfile.fs.fileExistsSync(loaderPath)) {
-            plugins.smartfile.fs.removeSync(loaderPath);
+          if (plugins.fs.existsSync(loaderPath)) {
+            plugins.fs.rmSync(loaderPath, { force: true });
           }
         } catch (e) {
           // Ignore cleanup errors

package/ts/tstest.classes.runtime.chromium.ts

@@ -107,7 +107,8 @@ export class ChromiumRuntimeAdapter extends RuntimeAdapter {
     const bundleFilePath = plugins.path.join(tsbundleCacheDirPath, bundleFileName);
 
     // lets bundle the test
-    await plugins.smartfile.fs.ensureEmptyDir(tsbundleCacheDirPath);
+    try { await plugins.smartfsInstance.directory(tsbundleCacheDirPath).recursive().delete(); } catch (e) { /* may not exist */ }
+    await plugins.smartfsInstance.directory(tsbundleCacheDirPath).recursive().create();
     await this.tsbundleInstance.build(process.cwd(), testFile, bundleFilePath, {
       bundler: 'esbuild',
     });
@@ -116,15 +117,13 @@ export class ChromiumRuntimeAdapter extends RuntimeAdapter {
     const { httpPort, wsPort } = await this.findFreePorts();
 
     // lets create a server
-    const server = new plugins.typedserver.servertools.Server({
+    const server = new plugins.typedserver.TypedServer({
       cors: true,
       port: httpPort,
+      serveDir: tsbundleCacheDirPath,
     });
-    server.addRoute(
-      '/test',
-      new plugins.typedserver.servertools.Handler('GET', async (_req, res) => {
-        res.type('.html');
-        res.write(`
+    server.addRoute('/test', 'GET', async () => {
+      return new Response(`
         <html>
           <head>
             <script>
@@ -134,11 +133,8 @@ export class ChromiumRuntimeAdapter extends RuntimeAdapter {
           </head>
           <body></body>
         </html>
-      `);
-        res.end();
-      })
-    );
-    server.addRoute('/*splat', new plugins.typedserver.servertools.HandlerStatic(tsbundleCacheDirPath));
+      `, { headers: { 'Content-Type': 'text/html' } });
+    });
     await server.start();
 
     // lets handle realtime comms

package/ts/tstest.classes.runtime.deno.ts

@@ -10,6 +10,20 @@ import { TapParser } from './tstest.classes.tap.parser.js';
 import { TsTestLogger } from './tstest.logging.js';
 import type { Runtime } from './tstest.classes.runtime.parser.js';
 
+/**
+ * Default Deno permissions used when no directives override them.
+ */
+export const DENO_DEFAULT_PERMISSIONS = [
+  '--allow-read',
+  '--allow-env',
+  '--allow-net',
+  '--allow-write',
+  '--allow-sys',
+  '--allow-import',
+  '--node-modules-dir',
+  '--sloppy-imports',
+];
+
 /**
  * Deno runtime adapter
  * Executes tests using the Deno runtime
@@ -36,25 +50,16 @@ export class DenoRuntimeAdapter extends RuntimeAdapter {
     const denoJsonPath = plugins.path.join(process.cwd(), 'deno.json');
     const denoJsoncPath = plugins.path.join(process.cwd(), 'deno.jsonc');
 
-    if (plugins.smartfile.fs.fileExistsSync(denoJsonPath)) {
+    if (plugins.fs.existsSync(denoJsonPath)) {
       configPath = denoJsonPath;
-    } else if (plugins.smartfile.fs.fileExistsSync(denoJsoncPath)) {
+    } else if (plugins.fs.existsSync(denoJsoncPath)) {
       configPath = denoJsoncPath;
     }
 
     return {
       ...super.getDefaultOptions(),
       configPath,
-      permissions: [
-        '--allow-read',
-        '--allow-env',
-        '--allow-net',
-        '--allow-write',
-        '--allow-sys',        // Allow system info access
-        '--allow-import',     // Allow npm/node imports
-        '--node-modules-dir', // Enable Node.js compatibility mode
-        '--sloppy-imports',   // Allow .js imports to resolve to .ts files
-      ],
+      permissions: [...DENO_DEFAULT_PERMISSIONS],
     };
   }
 
@@ -102,16 +107,7 @@ export class DenoRuntimeAdapter extends RuntimeAdapter {
     const args: string[] = ['run'];
 
     // Add permissions
-    const permissions = mergedOptions.permissions || [
-      '--allow-read',
-      '--allow-env',
-      '--allow-net',
-      '--allow-write',
-      '--allow-sys',
-      '--allow-import',
-      '--node-modules-dir',
-      '--sloppy-imports',
-    ];
+    const permissions = mergedOptions.permissions || [...DENO_DEFAULT_PERMISSIONS];
     args.push(...permissions);
 
     // Add config file if specified
@@ -173,7 +169,7 @@ export class DenoRuntimeAdapter extends RuntimeAdapter {
     // Check for 00init.ts file in test directory
     const testDir = plugins.path.dirname(testFile);
     const initFile = plugins.path.join(testDir, '00init.ts');
-    const initFileExists = await plugins.smartfile.fs.fileExists(initFile);
+    const initFileExists = await plugins.smartfsInstance.file(initFile).exists();
 
     let runCommand = fullCommand;
     let loaderPath: string | null = null;
@@ -187,7 +183,7 @@ import '${absoluteInitFile.replace(/\\/g, '/')}';
 import '${absoluteTestFile.replace(/\\/g, '/')}';
 `;
       loaderPath = plugins.path.join(testDir, `.loader_${plugins.path.basename(testFile)}`);
-      await plugins.smartfile.memory.toFs(loaderContent, loaderPath);
+      await plugins.smartfsInstance.file(loaderPath).write(loaderContent);
 
       // Rebuild command with loader file
       const loaderCommand = this.createCommand(loaderPath, mergedOptions);
@@ -200,8 +196,8 @@ import '${absoluteTestFile.replace(/\\/g, '/')}';
     if (loaderPath) {
       const cleanup = () => {
         try {
-          if (plugins.smartfile.fs.fileExistsSync(loaderPath)) {
-            plugins.smartfile.fs.removeSync(loaderPath);
+          if (plugins.fs.existsSync(loaderPath)) {
+            plugins.fs.rmSync(loaderPath, { force: true });
           }
         } catch (e) {
           // Ignore cleanup errors

package/ts/tstest.classes.runtime.docker.ts

@@ -102,7 +102,7 @@ export class DockerRuntimeAdapter extends RuntimeAdapter {
     }
 
     // Check if Dockerfile exists
-    if (!await plugins.smartfile.fs.fileExists(dockerfilePath)) {
+    if (!await plugins.smartfsInstance.file(dockerfilePath).exists()) {
       throw new Error(
         `Dockerfile not found: ${dockerfilePath}\n` +
         `Expected Dockerfile for Docker test variant.`

package/ts/tstest.classes.runtime.node.ts

@@ -123,7 +123,7 @@ export class NodeRuntimeAdapter extends RuntimeAdapter {
     // Check for 00init.ts file in test directory
     const testDir = plugins.path.dirname(testFile);
     const initFile = plugins.path.join(testDir, '00init.ts');
-    const initFileExists = await plugins.smartfile.fs.fileExists(initFile);
+    const initFileExists = await plugins.smartfsInstance.file(initFile).exists();
 
     // Determine which file to run
     let fileToRun = testFile;
@@ -138,7 +138,7 @@ import '${absoluteInitFile.replace(/\\/g, '/')}';
 import '${absoluteTestFile.replace(/\\/g, '/')}';
 `;
       loaderPath = plugins.path.join(testDir, `.loader_${plugins.path.basename(testFile)}`);
-      await plugins.smartfile.memory.toFs(loaderContent, loaderPath);
+      await plugins.smartfsInstance.file(loaderPath).write(loaderContent);
       fileToRun = loaderPath;
     }
 
@@ -150,8 +150,8 @@ import '${absoluteTestFile.replace(/\\/g, '/')}';
     if (loaderPath) {
       const cleanup = () => {
         try {
-          if (plugins.smartfile.fs.fileExistsSync(loaderPath)) {
-            plugins.smartfile.fs.removeSync(loaderPath);
+          if (plugins.fs.existsSync(loaderPath)) {
+            plugins.fs.rmSync(loaderPath, { force: true });
           }
         } catch (e) {
           // Ignore cleanup errors

package/ts/tstest.classes.tap.parser.ts

@@ -497,12 +497,10 @@ export class TapParser {
    */
   private async handleSnapshot(snapshotData: { path: string; content: string; action: string }) {
     try {
-      const smartfile = await import('@push.rocks/smartfile');
-      
       if (snapshotData.action === 'compare') {
         // Try to read existing snapshot
         try {
-          const existingSnapshot = await smartfile.fs.toStringSync(snapshotData.path);
+          const existingSnapshot = await plugins.smartfsInstance.file(snapshotData.path).encoding('utf8').read() as string;
           if (existingSnapshot !== snapshotData.content) {
             // Snapshot mismatch
             if (this.logger) {
@@ -520,8 +518,8 @@ export class TapParser {
           if (error.code === 'ENOENT') {
             // Snapshot doesn't exist, create it
             const dirPath = snapshotData.path.substring(0, snapshotData.path.lastIndexOf('/'));
-            await smartfile.fs.ensureDir(dirPath);
-            await smartfile.memory.toFs(snapshotData.content, snapshotData.path);
+            await plugins.smartfsInstance.directory(dirPath).recursive().create();
+            await plugins.smartfsInstance.file(snapshotData.path).write(snapshotData.content);
             if (this.logger) {
               this.logger.testConsoleOutput(`Snapshot created: ${snapshotData.path}`);
             }
@@ -532,8 +530,8 @@ export class TapParser {
       } else if (snapshotData.action === 'update') {
         // Update snapshot
         const dirPath = snapshotData.path.substring(0, snapshotData.path.lastIndexOf('/'));
-        await smartfile.fs.ensureDir(dirPath);
-        await smartfile.memory.toFs(snapshotData.content, snapshotData.path);
+        await plugins.smartfsInstance.directory(dirPath).recursive().create();
+        await plugins.smartfsInstance.file(snapshotData.path).write(snapshotData.content);
         if (this.logger) {
           this.logger.testConsoleOutput(`Snapshot updated: ${snapshotData.path}`);
         }

package/ts/tstest.classes.testdirectory.ts

@@ -1,8 +1,10 @@
 import * as plugins from './tstest.plugins.js';
 import * as paths from './tstest.paths.js';
-import { SmartFile } from '@push.rocks/smartfile';
+import { type SmartFile, SmartFileFactory } from '@push.rocks/smartfile';
 import { TestExecutionMode } from './index.js';
 
+const smartFileFactory = SmartFileFactory.nodeFs();
+
 // tap related stuff
 import { TapCombinator } from './tstest.classes.tap.combinator.js';
 import { TapParser } from './tstest.classes.tap.parser.js';
@@ -45,28 +47,28 @@ export class TestDirectory {
     switch (this.executionMode) {
       case TestExecutionMode.FILE:
         // Single file mode
-        const filePath = plugins.path.isAbsolute(this.testPath) 
-          ? this.testPath 
+        const filePath = plugins.path.isAbsolute(this.testPath)
+          ? this.testPath
           : plugins.path.join(this.cwd, this.testPath);
-        
-        if (await plugins.smartfile.fs.fileExists(filePath)) {
-          this.testfileArray = [await plugins.smartfile.SmartFile.fromFilePath(filePath)];
+
+        if (await plugins.smartfsInstance.file(filePath).exists()) {
+          this.testfileArray = [await smartFileFactory.fromFilePath(filePath)];
         } else {
           throw new Error(`Test file not found: ${filePath}`);
         }
         break;
         
       case TestExecutionMode.GLOB:
-        // Glob pattern mode - use listFileTree which supports glob patterns
+        // Glob pattern mode - use Node.js fs.globSync for full glob support
         const globPattern = this.testPath;
-        const matchedFiles = await plugins.smartfile.fs.listFileTree(this.cwd, globPattern);
-        
+        const matchedFiles = plugins.fs.globSync(globPattern, { cwd: this.cwd });
+
         this.testfileArray = await Promise.all(
-          matchedFiles.map(async (filePath) => {
-            const absolutePath = plugins.path.isAbsolute(filePath) 
-              ? filePath 
+          matchedFiles.map(async (filePath: string) => {
+            const absolutePath = plugins.path.isAbsolute(filePath)
+              ? filePath
               : plugins.path.join(this.cwd, filePath);
-            return await plugins.smartfile.SmartFile.fromFilePath(absolutePath);
+            return await smartFileFactory.fromFilePath(absolutePath);
           })
         );
         break;
@@ -79,19 +81,16 @@ export class TestDirectory {
         const tsPattern = '**/test*.ts';
         const dockerPattern = '**/*.docker.sh';
 
-        const [tsFiles, dockerFiles] = await Promise.all([
-          plugins.smartfile.fs.listFileTree(dirPath, tsPattern),
-          plugins.smartfile.fs.listFileTree(dirPath, dockerPattern),
-        ]);
-
-        const allTestFiles = [...tsFiles, ...dockerFiles];
+        const tsFiles = plugins.fs.globSync(tsPattern, { cwd: dirPath });
+        const dockerFiles = plugins.fs.globSync(dockerPattern, { cwd: dirPath });
+        const allTestFiles = [...tsFiles, ...dockerFiles] as string[];
 
         this.testfileArray = await Promise.all(
           allTestFiles.map(async (filePath) => {
             const absolutePath = plugins.path.isAbsolute(filePath)
               ? filePath
               : plugins.path.join(dirPath, filePath);
-            return await plugins.smartfile.SmartFile.fromFilePath(absolutePath);
+            return await smartFileFactory.fromFilePath(absolutePath);
           })
         );
         break;

package/ts/tstest.classes.testfile.directives.ts

@@ -0,0 +1,226 @@
+import * as plugins from './tstest.plugins.js';
+import type { DenoOptions, RuntimeOptions } from './tstest.classes.runtime.adapter.js';
+import type { Runtime } from './tstest.classes.runtime.parser.js';
+import { DENO_DEFAULT_PERMISSIONS } from './tstest.classes.runtime.deno.js';
+
+type DirectiveScope = Runtime | 'global';
+
+export interface ITestFileDirective {
+  scope: DirectiveScope;
+  key: string;
+  value?: string;
+}
+
+export interface IParsedDirectives {
+  deno: ITestFileDirective[];
+  node: ITestFileDirective[];
+  bun: ITestFileDirective[];
+  chromium: ITestFileDirective[];
+  global: ITestFileDirective[];
+}
+
+const VALID_SCOPES = new Set<string>(['deno', 'node', 'bun', 'chromium']);
+
+const DENO_PERMISSION_MAP: Record<string, string> = {
+  allowAll: '--allow-all',
+  allowRun: '--allow-run',
+  allowFfi: '--allow-ffi',
+  allowHrtime: '--allow-hrtime',
+  allowRead: '--allow-read',
+  allowWrite: '--allow-write',
+  allowNet: '--allow-net',
+  allowEnv: '--allow-env',
+  allowSys: '--allow-sys',
+};
+
+function createEmptyDirectives(): IParsedDirectives {
+  return { deno: [], node: [], bun: [], chromium: [], global: [] };
+}
+
+/**
+ * Parse tstest directives from file content.
+ * Scans comments at the top of the file (before any code).
+ */
+export function parseDirectivesFromContent(content: string): IParsedDirectives {
+  const result = createEmptyDirectives();
+  const lines = content.split('\n');
+  const maxLines = Math.min(lines.length, 30);
+
+  for (let i = 0; i < maxLines; i++) {
+    const line = lines[i].trim();
+
+    // Skip empty lines
+    if (line === '') continue;
+
+    // Stop at first non-comment line
+    if (!line.startsWith('//')) break;
+
+    // Match tstest directive: // tstest:<rest>
+    const match = line.match(/^\/\/\s*tstest:(.+)$/);
+    if (!match) continue;
+
+    const parts = match[1].split(':');
+    if (parts.length < 2) {
+      console.warn(`Warning: malformed tstest directive: "${line}"`);
+      continue;
+    }
+
+    const scopeStr = parts[0].trim();
+    const key = parts[1].trim();
+    const value = parts.length > 2 ? parts.slice(2).join(':').trim() : undefined;
+
+    // Handle global directives (env, timeout)
+    if (scopeStr === 'env' || scopeStr === 'timeout') {
+      result.global.push({
+        scope: 'global',
+        key: scopeStr,
+        value: key + (value !== undefined ? ':' + value : ''),
+      });
+      continue;
+    }
+
+    if (!VALID_SCOPES.has(scopeStr)) {
+      console.warn(`Warning: unknown tstest directive scope "${scopeStr}" in: "${line}"`);
+      continue;
+    }
+
+    const scope = scopeStr as Runtime;
+    result[scope].push({ scope, key, value });
+  }
+
+  return result;
+}
+
+/**
+ * Parse directives from a test file on disk.
+ */
+export async function parseDirectivesFromFile(filePath: string): Promise<IParsedDirectives> {
+  try {
+    const content = plugins.fs.readFileSync(filePath, 'utf8');
+    return parseDirectivesFromContent(content);
+  } catch {
+    return createEmptyDirectives();
+  }
+}
+
+/**
+ * Merge directives from 00init.ts and the test file.
+ * Test file directives are appended (take effect after init directives).
+ */
+export function mergeDirectives(init: IParsedDirectives, testFile: IParsedDirectives): IParsedDirectives {
+  return {
+    deno: [...init.deno, ...testFile.deno],
+    node: [...init.node, ...testFile.node],
+    bun: [...init.bun, ...testFile.bun],
+    chromium: [...init.chromium, ...testFile.chromium],
+    global: [...init.global, ...testFile.global],
+  };
+}
+
+/**
+ * Check if any directives exist for any scope.
+ */
+export function hasDirectives(directives: IParsedDirectives): boolean {
+  return (
+    directives.deno.length > 0 ||
+    directives.node.length > 0 ||
+    directives.bun.length > 0 ||
+    directives.chromium.length > 0 ||
+    directives.global.length > 0
+  );
+}
+
+/**
+ * Convert parsed directives into DenoOptions.
+ */
+function directivesToDenoOptions(directives: IParsedDirectives): DenoOptions | undefined {
+  const denoDirectives = directives.deno;
+  if (denoDirectives.length === 0 && directives.global.length === 0) return undefined;
+
+  const options: DenoOptions = {};
+  const extraPermissions: string[] = [];
+  const extraArgs: string[] = [];
+  const env: Record<string, string> = {};
+  let useAllowAll = false;
+
+  for (const d of denoDirectives) {
+    if (d.key === 'allowAll') {
+      useAllowAll = true;
+    } else if (DENO_PERMISSION_MAP[d.key]) {
+      extraPermissions.push(DENO_PERMISSION_MAP[d.key]);
+    } else if (d.key === 'flag' && d.value) {
+      extraArgs.push(d.value);
+    }
+  }
+
+  // Process global directives
+  for (const d of directives.global) {
+    if (d.key === 'env' && d.value) {
+      const eqIndex = d.value.indexOf('=');
+      if (eqIndex > 0) {
+        env[d.value.substring(0, eqIndex)] = d.value.substring(eqIndex + 1);
+      }
+    }
+  }
+
+  if (useAllowAll) {
+    // --allow-all replaces individual permissions, but keep compatibility flags
+    options.permissions = ['--allow-all', '--node-modules-dir', '--sloppy-imports'];
+  } else if (extraPermissions.length > 0) {
+    // Start with defaults and add extra permissions (deduplicated)
+    const allPermissions = [...DENO_DEFAULT_PERMISSIONS];
+    for (const p of extraPermissions) {
+      if (!allPermissions.includes(p)) {
+        allPermissions.push(p);
+      }
+    }
+    options.permissions = allPermissions;
+  }
+
+  if (extraArgs.length > 0) options.extraArgs = extraArgs;
+  if (Object.keys(env).length > 0) options.env = env;
+
+  // Return undefined if nothing was set
+  if (!options.permissions && !options.extraArgs && !options.env) return undefined;
+  return options;
+}
+
+/**
+ * Convert parsed directives into RuntimeOptions for Node/Bun (flag directives only).
+ */
+function directivesToGenericOptions(directives: ITestFileDirective[], globalDirectives: ITestFileDirective[]): RuntimeOptions | undefined {
+  const extraArgs: string[] = [];
+  const env: Record<string, string> = {};
+
+  for (const d of directives) {
+    if (d.key === 'flag' && d.value) {
+      extraArgs.push(d.value);
+    }
+  }
+
+  for (const d of globalDirectives) {
+    if (d.key === 'env' && d.value) {
+      const eqIndex = d.value.indexOf('=');
+      if (eqIndex > 0) {
+        env[d.value.substring(0, eqIndex)] = d.value.substring(eqIndex + 1);
+      }
+    }
+  }
+
+  if (extraArgs.length === 0 && Object.keys(env).length === 0) return undefined;
+
+  const options: RuntimeOptions = {};
+  if (extraArgs.length > 0) options.extraArgs = extraArgs;
+  if (Object.keys(env).length > 0) options.env = env;
+  return options;
+}
+
+/**
+ * Convert parsed directives into RuntimeOptions for a specific runtime.
+ */
+export function directivesToRuntimeOptions(directives: IParsedDirectives, runtime: Runtime): RuntimeOptions | undefined {
+  if (runtime === 'deno') {
+    return directivesToDenoOptions(directives);
+  }
+  return directivesToGenericOptions(directives[runtime] || [], directives.global);
+}