slicejs-web-framework 3.4.4 → 3.5.1

package/slicejs-cli/tests/path-helper.test.js

@@ -1,206 +0,0 @@
-import { test, describe, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import path from 'node:path';
-import fs from 'node:fs';
-import { createTestProject, cleanupTestProject } from './helpers/setup.js';
-
-/** @type {string} */
-let tmpRoot;
-const origInitCwd = process.env.INIT_CWD;
-
-before(async () => {
-  tmpRoot = await createTestProject();
-  process.env.INIT_CWD = tmpRoot;
-});
-
-after(async () => {
-  if (origInitCwd === undefined) {
-    delete process.env.INIT_CWD;
-  } else {
-    process.env.INIT_CWD = origInitCwd;
-  }
-  await cleanupTestProject(tmpRoot);
-});
-
-describe('getProjectRoot', () => {
-  test('resolves project root via INIT_CWD when pointing to a real project', async () => {
-    const { getProjectRoot } = await import('../commands/utils/PathHelper.js');
-    const root = getProjectRoot(import.meta.url);
-    assert.ok(root, 'should return a path');
-    assert.ok(fs.existsSync(root), `resolved path should exist: ${root}`);
-    assert.equal(path.resolve(root), path.resolve(tmpRoot));
-  });
-
-  test('resolves project root via cwd when INIT_CWD is not set', async () => {
-    const prev = process.env.INIT_CWD;
-    delete process.env.INIT_CWD;
-    try {
-      const { getProjectRoot } = await import('../commands/utils/PathHelper.js');
-      const root = getProjectRoot(import.meta.url);
-      assert.ok(root, 'should return a path');
-      assert.ok(fs.existsSync(root), `resolved path should exist: ${root}`);
-    } finally {
-      process.env.INIT_CWD = prev;
-    }
-  });
-});
-
-describe('getSrcPath', () => {
-  test('returns src path relative to project root', async () => {
-    const { getSrcPath } = await import('../commands/utils/PathHelper.js');
-    const srcPath = getSrcPath(import.meta.url);
-    assert.ok(srcPath.endsWith('src'), `should end with 'src': ${srcPath}`);
-    assert.ok(fs.existsSync(srcPath), `src path should exist: ${srcPath}`);
-  });
-
-  test('accepts subpath segments', async () => {
-    const { getSrcPath } = await import('../commands/utils/PathHelper.js');
-    const result = getSrcPath(import.meta.url, 'Components', 'components.js');
-    assert.ok(result.endsWith('src/Components/components.js') || result.endsWith('src\\Components\\components.js'));
-    assert.ok(fs.existsSync(result), `file should exist: ${result}`);
-  });
-});
-
-describe('getApiPath', () => {
-  test('returns api path relative to project root', async () => {
-    const { getApiPath } = await import('../commands/utils/PathHelper.js');
-    const apiPath = getApiPath(import.meta.url);
-    assert.ok(apiPath.endsWith('api'), `should end with 'api': ${apiPath}`);
-    assert.ok(fs.existsSync(apiPath), `api path should exist: ${apiPath}`);
-  });
-
-  test('appends subpath to api', async () => {
-    const { getApiPath } = await import('../commands/utils/PathHelper.js');
-    const result = getApiPath(import.meta.url, 'index.js');
-    assert.ok(result.endsWith('api/index.js') || result.endsWith('api\\index.js'));
-  });
-});
-
-describe('getDistPath', () => {
-  test('returns dist path relative to project root', async () => {
-    const { getDistPath } = await import('../commands/utils/PathHelper.js');
-    const distPath = getDistPath(import.meta.url);
-    assert.ok(distPath.endsWith('dist'), `should end with 'dist': ${distPath}`);
-  });
-});
-
-describe('getConfigPath', () => {
-  test('returns sliceConfig.json path', async () => {
-    const { getConfigPath } = await import('../commands/utils/PathHelper.js');
-    const configPath = getConfigPath(import.meta.url);
-    assert.ok(configPath.endsWith('sliceConfig.json'), `should end with 'sliceConfig.json': ${configPath}`);
-    assert.ok(fs.existsSync(configPath), `config file should exist: ${configPath}`);
-  });
-});
-
-describe('getComponentsJsPath', () => {
-  test('returns components.js path', async () => {
-    const { getComponentsJsPath } = await import('../commands/utils/PathHelper.js');
-    const compPath = getComponentsJsPath(import.meta.url);
-    assert.ok(compPath.endsWith('components.js'), `should end with 'components.js': ${compPath}`);
-    assert.ok(fs.existsSync(compPath), `components.js should exist: ${compPath}`);
-  });
-});
-
-describe('getPath', () => {
-  test('joins arbitrary segments to project root', async () => {
-    const { getPath } = await import('../commands/utils/PathHelper.js');
-    const result = getPath(import.meta.url, 'src', 'routes.js');
-    assert.ok(result.endsWith('routes.js'), `should end with 'routes.js': ${result}`);
-    assert.ok(fs.existsSync(result), `routes.js should exist: ${result}`);
-  });
-
-  test('sanitizes leading slashes from segments', async () => {
-    const { getPath } = await import('../commands/utils/PathHelper.js');
-    const result = getPath(import.meta.url, '/src/', '/routes.js');
-    assert.ok(result.endsWith('routes.js'), `should handle sanitized segments: ${result}`);
-  });
-});
-
-describe('resolveProjectRoot (fallback via candidates)', () => {
-  test('uses candidates() when INIT_CWD is not a valid path', async () => {
-    const orig = process.env.INIT_CWD;
-    process.env.INIT_CWD = 'C:\\nonexistent\\path';
-
-    try {
-      const { getProjectRoot } = await import('../commands/utils/PathHelper.js');
-      const root = getProjectRoot(import.meta.url);
-      assert.ok(root, 'should return a path');
-      assert.ok(fs.existsSync(root), `fallback path should exist: ${root}`);
-    } finally {
-      process.env.INIT_CWD = orig;
-    }
-  });
-});
-
-describe('joinRoot', () => {
-  test('joins segments relative to explicit root path', async () => {
-    const { joinRoot } = await import('../commands/utils/PathHelper.js');
-    const root = path.resolve('/test/project');
-    const result = joinRoot(root, 'src', 'components');
-    assert.equal(result, path.join(root, 'src', 'components'));
-  });
-
-  test('sanitizes leading slashes from segments', async () => {
-    const { joinRoot } = await import('../commands/utils/PathHelper.js');
-    const root = path.resolve('/test/project');
-    const result = joinRoot(root, '/src', '/components');
-    assert.equal(result, path.join(root, 'src', 'components'));
-  });
-
-  test('handles single segment', async () => {
-    const { joinRoot } = await import('../commands/utils/PathHelper.js');
-    const root = path.resolve('/test/project');
-    const result = joinRoot(root, 'package.json');
-    assert.equal(result, path.join(root, 'package.json'));
-  });
-
-  test('handles empty segments', async () => {
-    const { joinRoot } = await import('../commands/utils/PathHelper.js');
-    const root = path.resolve('/test/project');
-    const result = joinRoot(root);
-    assert.equal(result, root);
-  });
-});
-
-describe('getConfigPath with explicit root', () => {
-  test('returns sliceConfig.json under explicit root', async () => {
-    const { getConfigPath } = await import('../commands/utils/PathHelper.js');
-    const explicitRoot = path.resolve('/custom/project');
-    const result = getConfigPath(import.meta.url, explicitRoot);
-    assert.equal(result, path.join(explicitRoot, 'src', 'sliceConfig.json'));
-  });
-
-  test('returns sliceConfig.json without root (auto-resolve)', async () => {
-    const { getConfigPath } = await import('../commands/utils/PathHelper.js');
-    const result = getConfigPath(import.meta.url);
-    assert.ok(result.endsWith('sliceConfig.json'));
-    assert.ok(fs.existsSync(result));
-  });
-});
-
-describe('getComponentsJsPath with explicit root', () => {
-  test('returns components.js under explicit root', async () => {
-    const { getComponentsJsPath } = await import('../commands/utils/PathHelper.js');
-    const explicitRoot = path.resolve('/custom/project');
-    const result = getComponentsJsPath(import.meta.url, explicitRoot);
-    assert.equal(result, path.join(explicitRoot, 'src', 'Components', 'components.js'));
-  });
-
-  test('returns components.js without root (auto-resolve)', async () => {
-    const { getComponentsJsPath } = await import('../commands/utils/PathHelper.js');
-    const result = getComponentsJsPath(import.meta.url);
-    assert.ok(result.endsWith('components.js'));
-    assert.ok(fs.existsSync(result));
-  });
-});
-
-describe('getSrcPath integration', () => {
-  test('getSrcPath matches joinRoot with src prefix', async () => {
-    const { getSrcPath, getProjectRoot, joinRoot } = await import('../commands/utils/PathHelper.js');
-    const root = getProjectRoot(import.meta.url);
-    const viaHelper = getSrcPath(import.meta.url, 'Components', 'components.js');
-    const viaJoinRoot = joinRoot(root, 'src', 'Components', 'components.js');
-    assert.equal(viaHelper, viaJoinRoot);
-  });
-});

package/slicejs-cli/tests/perf-budget.test.js

@@ -1,84 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import fs from 'fs-extra';
-import { createTestProject, cleanupTestProject } from './helpers/setup.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const FIXTURES = path.resolve(__dirname, 'e2e/fixtures/components');
-const FW_PKG = path.resolve(__dirname, '../node_modules/slicejs-web-framework');
-
-// Performance budgets for the realistic starter app (App Shell + the vendored
-// starter components). Bundle byte sizes are fully deterministic, so a surprise
-// failure here means a change degraded the output — review it, and only bump a
-// budget when the growth is intentional. (Actuals shown for reference.)
-const BUDGET = {
-  bundleCount: 5, //            actual: 4
-  totalBundleBytes: 165_000, // actual: ~133.6 KB
-  criticalBytes: 51_200, //     actual: ~40.8 KB (bundler's own critical cap is 50 KB)
-  frameworkBytes: 85_000, //    actual: ~67.4 KB (tracks the slicejs-web-framework package)
-  buildMs: 30_000, //           actual: ~1 s — generous ceiling to catch pathological slowdowns
-};
-
-async function assembleAndBuild() {
-  process.env.NODE_ENV = 'production';
-  const app = await createTestProject();
-
-  await fs.ensureDir(path.join(app, 'node_modules'));
-  await fs.copy(FW_PKG, path.join(app, 'node_modules', 'slicejs-web-framework'), { dereference: true });
-
-  await fs.copy(path.join(FIXTURES, 'Visual'), path.join(app, 'src', 'Components', 'Visual'));
-  await fs.copy(path.join(FIXTURES, 'Service'), path.join(app, 'src', 'Components', 'Service'));
-
-  process.env.INIT_CWD = app;
-  (await import('../commands/listComponents/listComponents.js')).default();
-
-  const build = (await import('../commands/build/build.js')).default;
-  const start = Date.now();
-  const ok = await build({ minify: true, obfuscate: true });
-  const buildMs = Date.now() - start;
-  assert.equal(ok, true, 'build should succeed');
-  return { app, buildMs };
-}
-
-test('production build stays within performance budgets', async () => {
-  const { app, buildMs } = await assembleAndBuild();
-  try {
-    const bundlesDir = path.join(app, 'dist', 'bundles');
-    const files = (await fs.readdir(bundlesDir)).filter(
-      (f) => f.startsWith('slice-bundle.') && f.endsWith('.js')
-    );
-
-    const sizes = {};
-    let totalBundleBytes = 0;
-    for (const f of files) {
-      sizes[f] = (await fs.stat(path.join(bundlesDir, f))).size;
-      totalBundleBytes += sizes[f];
-    }
-    const cfg = await fs.readJson(path.join(bundlesDir, 'bundle.config.json'));
-    const criticalBytes = sizes['slice-bundle.critical.js'] || 0;
-    const frameworkBytes = sizes['slice-bundle.framework.js'] || 0;
-
-    // Always print the metrics so trends are visible even on a passing run.
-    console.log(
-      `\n  [perf] bundles=${files.length} total=${Math.round(totalBundleBytes / 1024)}KB ` +
-        `critical=${Math.round(criticalBytes / 1024)}KB framework=${Math.round(frameworkBytes / 1024)}KB ` +
-        `requestReduction=${100 - Math.round((files.length / cfg.stats.totalComponents) * 100)}% build=${buildMs}ms`
-    );
-
-    assert.ok(files.length <= BUDGET.bundleCount, `bundle count ${files.length} exceeds budget ${BUDGET.bundleCount}`);
-    assert.ok(
-      totalBundleBytes <= BUDGET.totalBundleBytes,
-      `total bundle bytes ${totalBundleBytes} exceeds budget ${BUDGET.totalBundleBytes}`
-    );
-    assert.ok(criticalBytes <= BUDGET.criticalBytes, `critical bundle ${criticalBytes} exceeds budget ${BUDGET.criticalBytes}`);
-    assert.ok(frameworkBytes <= BUDGET.frameworkBytes, `framework bundle ${frameworkBytes} exceeds budget ${BUDGET.frameworkBytes}`);
-    assert.ok(buildMs <= BUDGET.buildMs, `build took ${buildMs}ms, over budget ${BUDGET.buildMs}ms`);
-
-    // Sanity: the realistic app actually bundled its full component set.
-    assert.ok(cfg.stats.totalComponents >= 20, `unexpectedly few components bundled: ${cfg.stats.totalComponents}`);
-  } finally {
-    await cleanupTestProject(app);
-  }
-});

package/slicejs-cli/tests/postinstall-command.test.js

@@ -1,103 +0,0 @@
-import { test, describe } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { SLICE_SCRIPTS, verifySliceScriptsInPackageJson } from '../commands/utils/sliceScripts.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const clientPath = path.join(__dirname, '..', 'client.js');
-const source = fs.readFileSync(clientPath, 'utf-8');
-const initSource = fs.readFileSync(path.join(__dirname, '..', 'commands', 'init', 'init.js'), 'utf-8');
-
-test('postinstall command is registered in client.js', () => {
-  const hasSetupCommand = source.includes('.command("postinstall")');
-  assert.ok(hasSetupCommand, 'client.js must register a "postinstall" command');
-});
-
-test('postinstall command has a description', () => {
-  const match = source.match(/\.command\(["']postinstall["']\)\s*\.description\(["']([^"']+)["']\)/);
-  assert.ok(match, 'postinstall command must have a .description() call');
-  assert.ok(match[1].length > 0, 'postinstall command description must not be empty');
-});
-
-test('postinstall command checks npm_config_global environment variable', () => {
-  const hasGlobalCheck = source.includes('npm_config_global');
-  assert.ok(hasGlobalCheck, 'postinstall command must check npm_config_global to detect global installation');
-});
-
-test('postinstall command prints global install warning', () => {
-  const hasGlobalWarning = source.includes('Global installation');
-  assert.ok(hasGlobalWarning, 'postinstall command must warn about global installation');
-});
-
-test('postinstall command prints local install success message', () => {
-  const hasSuccessMsg = source.includes('installed successfully');
-  assert.ok(hasSuccessMsg, 'postinstall command must show success message for local installs');
-});
-
-test('postinstall command uses getProjectRoot from PathHelper', () => {
-  const hasPathHelper = source.includes("getProjectRoot(import.meta.url)");
-  assert.ok(hasPathHelper, 'postinstall command must use getProjectRoot resolver');
-});
-
-test('postinstall command writes npm scripts to package.json via fs', () => {
-  const hasFsWrite = source.includes('writeFileSync(pkgPath');
-  assert.ok(hasFsWrite, 'postinstall command must write scripts to package.json');
-});
-
-test('SLICE_SCRIPTS contains every slice:* command', () => {
-  const expected = [
-    'slice:init', 'slice:dev', 'slice:build', 'slice:start',
-    'slice:create', 'slice:list', 'slice:delete',
-    'slice:get', 'slice:browse', 'slice:sync',
-    'slice:doctor', 'slice:version', 'slice:help', 'slice:types'
-  ];
-  for (const script of expected) {
-    assert.ok(SLICE_SCRIPTS[script], `SLICE_SCRIPTS must define ${script}`);
-    assert.ok(SLICE_SCRIPTS[script].includes('slicejs-cli/client.js'), `${script} must run the local slicejs-cli client`);
-  }
-  assert.equal(Object.keys(SLICE_SCRIPTS).length, expected.length, 'no unexpected scripts in SLICE_SCRIPTS');
-});
-
-test('postinstall command and slice init share the same SLICE_SCRIPTS', () => {
-  assert.ok(source.includes('SLICE_SCRIPTS'), 'client.js postinstall must use SLICE_SCRIPTS');
-  assert.ok(source.includes("from './commands/utils/sliceScripts.js'"), 'client.js must import sliceScripts.js');
-  assert.ok(source.includes('verifySliceScriptsInPackageJson'), 'client.js postinstall must import verifySliceScriptsInPackageJson');
-  assert.ok(initSource.includes('Object.assign(pkg.scripts, SLICE_SCRIPTS)'), 'init.js must apply SLICE_SCRIPTS');
-  assert.ok(initSource.includes("from '../utils/sliceScripts.js'"), 'init.js must import sliceScripts.js');
-});
-
-test('postinstall command action is a function', () => {
-  const SetupActionPattern = /\.command\(["']postinstall["']\)[\s\S]*?\.action\(\(\)\s*=>\s*\{[\s\S]*?\}\)/;
-  const match = source.match(SetupActionPattern);
-  assert.ok(match, 'postinstall command must have an .action() with arrow function');
-});
-
-test('postinstall command provides npm uninstall -g instruction for global installs', () => {
-  const hasUninstallInstruction = source.includes('npm uninstall -g slicejs-cli');
-  assert.ok(hasUninstallInstruction, 'postinstall command must tell users how to uninstall global CLI');
-});
-
-describe('verifySliceScriptsInPackageJson', () => {
-  test('returns empty missing when all scripts are present', () => {
-    const pkgPath = path.join(__dirname, '..', 'package.json');
-    const { missing } = verifySliceScriptsInPackageJson(pkgPath);
-    const expected = Object.keys(SLICE_SCRIPTS);
-    for (const script of expected) {
-      assert.ok(!missing.includes(script), `${script} should not be missing from the CLI package.json`);
-    }
-  });
-
-  test('returns all scripts as missing when pkg has no scripts', () => {
-    const tmpDir = fs.mkdtempSync(path.join(__dirname, '..', 'tmp-test-'));
-    try {
-      const pkgPath = path.join(tmpDir, 'package.json');
-      fs.writeFileSync(pkgPath, JSON.stringify({ name: 'test' }));
-      const { missing } = verifySliceScriptsInPackageJson(pkgPath);
-      assert.equal(missing.length, Object.keys(SLICE_SCRIPTS).length, 'all scripts should be missing');
-    } finally {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-});

package/slicejs-cli/tests/property-mangling-regression.test.js

@@ -1,182 +0,0 @@
-import { test, describe } from 'node:test';
-import assert from 'node:assert/strict';
-import { minify } from 'terser';
-
-const BUGGY_REGEX = /^(slice|_|\$|on[A-Z]|get|set|has|is)/;
-
-const terserConfig = (regex) => ({
-  compress: { drop_console: false, drop_debugger: true, unused: false, side_effects: false, reduce_vars: false, collapse_vars: false },
-  mangle: {
-    reserved: ['slice', 'window', 'document', 'HTMLElement', 'addEventListener', 'removeEventListener', 'customElements', 'define', 'fetch', 'setTimeout', 'clearTimeout', 'console'],
-    properties: regex ? { regex } : false
-  },
-  format: { comments: false, beautify: false },
-  keep_fnames: true,
-  keep_classnames: true
-});
-
-async function mangleProps(code, regex) {
-  const result = await minify(code, terserConfig(regex));
-  if (result.error) throw result.error;
-  return result.code;
-}
-
-describe('property mangling — cross-file bug', () => {
-
-  describe('RED: buggy regex proves cross-file renaming differs', () => {
-
-    test('onClick is mangled to different short names in each file', async () => {
-      const fileA = `
-        class Pagination {
-          static props = { _p1: 0, sliceX: 0, onClick: { type: 'function' }, onChange: { type: 'function' } }
-          fire() { this.onClick() }
-        }
-      `;
-      const fileB = `
-        class Table {
-          trigger(comp) { comp.onClick() }
-        }
-      `;
-
-      const [minA, minB] = await Promise.all([
-        mangleProps(fileA, BUGGY_REGEX),
-        mangleProps(fileB, BUGGY_REGEX),
-      ]);
-
-      assert.doesNotMatch(minA, /onClick/, 'A: onClick must be mangled');
-      assert.doesNotMatch(minB, /onClick/, 'B: onClick must be mangled');
-
-      const thisCalls = [...minA.matchAll(/this\.([a-zA-Z])\s*\(/g)].map(m => m[1]);
-      const paramCalls = [...minB.matchAll(/\w+\.([a-zA-Z])\s*\(/g)].filter(m => m[1] !== 'props').map(m => m[1]);
-
-      assert.equal(thisCalls.length, 1, 'A: fire() calls this.onMangledClick()');
-      assert.equal(paramCalls.length, 1, 'B: trigger() calls comp.onMangledClick()');
-
-      assert.notEqual(
-        thisCalls[0], paramCalls[0],
-        `Mangled names differ: A=this.${thisCalls[0]}(), B=comp.${paramCalls[0]}()\n` +
-        `  A: ${minA}\n  B: ${minB}`
-      );
-    });
-
-    test('sliceId is mangled (should be preserved for cross-file access)', async () => {
-      const code = `class Foo { get() { return this.sliceId } }`;
-      const min = await mangleProps(code, BUGGY_REGEX);
-      assert.doesNotMatch(min, /sliceId/, 'sliceId should be mangled by buggy regex');
-    });
-
-    test('setPage is mangled to different short names in each file', async () => {
-      const fileA = `
-        class DataGridEngine {
-          doIt() { this._state(); this.setSort(); this.setPage(); this.setPageSize() }
-        }
-      `;
-      const fileB = `
-        class Table {
-          handle(p) { p.setPage() }
-        }
-      `;
-
-      const [minA, minB] = await Promise.all([
-        mangleProps(fileA, BUGGY_REGEX),
-        mangleProps(fileB, BUGGY_REGEX),
-      ]);
-
-      assert.doesNotMatch(minA, /setPage/, 'A: setPage must be mangled');
-      assert.doesNotMatch(minB, /setPage/, 'B: setPage must be mangled');
-
-      const thisCallsA = [...minA.matchAll(/this\.([a-zA-Z])\s*\(/g)].map(m => m[1]);
-      const paramCallsB = [...minB.matchAll(/\w+\.([a-zA-Z])\s*\(/g)].map(m => m[1]);
-
-      assert.equal(thisCallsA.length, 4, 'A should have 4 this.X() calls');
-      assert.equal(paramCallsB.length, 1, 'B should have 1 p.X() call');
-      assert.notEqual(
-        thisCallsA[2], paramCallsB[0],
-        `setPage is "${thisCallsA[2]}" in A but "${paramCallsB[0]}" in B\n` +
-        `  A: ${minA}\n  B: ${minB}`
-      );
-    });
-
-  });
-
-  describe('GREEN: fix variations prevent the bug', () => {
-
-    const FIXES = {
-      'properties: false (no mangling)': null,
-      'regex: /^_/ (private only)':      /^_/,
-    };
-
-    for (const [label, regex] of Object.entries(FIXES)) {
-
-      test(`${label}: onClick preserved (cross-file safe)`, async () => {
-        const fileA = `
-          class Pagination {
-            static props = { _p1: 0, sliceX: 0, onClick: { type: 'function' }, onChange: { type: 'function' } }
-            fire() { this.onClick() }
-          }
-        `;
-        const fileB = `class Table { trigger(comp) { comp.onClick() } }`;
-
-        const [minA, minB] = await Promise.all([
-          mangleProps(fileA, regex),
-          mangleProps(fileB, regex),
-        ]);
-
-        assert.ok(minA.includes('onClick'), `A must preserve onClick: ${minA}`);
-        assert.ok(minB.includes('onClick'), `B must preserve onClick: ${minB}`);
-      });
-
-      test(`${label}: sliceId preserved (cross-file safe)`, async () => {
-        const fileA = `class Foo { get() { return this.sliceId } }`;
-        const fileB = `class Bar { read(target) { return target.sliceId } }`;
-
-        const [minA, minB] = await Promise.all([
-          mangleProps(fileA, regex),
-          mangleProps(fileB, regex),
-        ]);
-
-        assert.ok(minA.includes('sliceId'), `A must preserve sliceId`);
-        assert.ok(minB.includes('sliceId'), `B must preserve sliceId`);
-      });
-
-      test(`${label}: setPage preserved (cross-file safe)`, async () => {
-        const fileA = `class Engine { handle(t) { t.setPage(1) } }`;
-        const fileB = `class Table { trigger(comp) { comp.setPage() } }`;
-
-        const [minA, minB] = await Promise.all([
-          mangleProps(fileA, regex),
-          mangleProps(fileB, regex),
-        ]);
-
-        assert.ok(minA.includes('setPage'), `A must preserve setPage: ${minA}`);
-        assert.ok(minB.includes('setPage'), `B must preserve setPage: ${minB}`);
-      });
-
-    }
-
-  });
-
-  describe('underscore-prefixed private props still get mangled', () => {
-
-    test('regex /^_/: _internal is mangled', async () => {
-      const code = `class Foo { constructor() { this._internal = 42; this.publicProp = 'x' } }`;
-      const min = await mangleProps(code, /^_/);
-      assert.doesNotMatch(min, /_internal/, '_internal should be mangled');
-      assert.ok(min.includes('publicProp'), 'publicProp preserved');
-    });
-
-    test('regex /^_/: $secret is NOT mangled', async () => {
-      const code = `class Foo { save() { this.$secret = 42 } }`;
-      const min = await mangleProps(code, /^_/);
-      assert.ok(min.includes('$secret'), '$secret preserved with /^_/');
-    });
-
-    test('properties: false: _internal is preserved (no mangling at all)', async () => {
-      const code = `class Foo { constructor() { this._internal = 42 } }`;
-      const min = await mangleProps(code, null);
-      assert.ok(min.includes('_internal'), '_internal survives with properties:false');
-    });
-
-  });
-
-});