@omega.js/web 0.1.0

package/dist/commands/install.js

@@ -0,0 +1,31 @@
+/**
+ * `omega install [type]` — `i local` links every declared @omega.js/* dep
+ * from the local Omega monorepo (idempotent); `i live`/`prod` restores
+ * registry specs TREE-WIDE (the publish-day inverse: every file: spec flips
+ * to the exact <linked version> and one install re-resolves from the registry).
+ */
+const Logger = require('../vendor/devkit/logger.js');
+const local = require('../vendor/devkit/local.js');
+
+const logger = new Logger('install');
+
+module.exports = async function (options) {
+  const type = options._[1] || 'prod';
+
+  if (['dev', 'd', 'development', 'local', 'l'].includes(type)) {
+    logger.log('Installing development (local Omega monorepo)...');
+    await local.linkLocalPackages({
+      dir: process.cwd(),
+      monorepoRoot: local.resolveMonorepoRoot(),
+      logger,
+    });
+    return logger.log('Development installation complete.');
+  }
+
+  logger.log('Installing production (restoring registry specs tree-wide)...');
+  const actions = await local.restoreRegistrySpecs({ dir: process.cwd(), logger });
+  const flipped = actions.filter((action) => action.action === 'flip').length;
+  logger.log(flipped > 0
+    ? `Production installation complete (${flipped} spec(s) restored to registry ranges).`
+    : 'Already on registry specs — nothing to flip.');
+};

package/dist/commands/lib/deploy-precheck.js

@@ -0,0 +1,43 @@
+/**
+ * deploy-precheck — the NETWORK half `omega setup` used to own
+ * ([#675](https://github.com/Omega-JS-Stack/omega/issues/675)).
+ *
+ * Setup's local half now rides every verb (ensure-target.js); what needs the
+ * network rides the ONE verb that needs the remote side right — `omega deploy`
+ * — as a precheck before the dispatch. For web that is one step: publish the
+ * .env cascade's keys as repo Actions secrets, which the scaffolded workflow's
+ * generated env block consumes.
+ *
+ * `--no-secrets` opts out — the same opt-out name on web, desktop and
+ * extension (parity; desktop's old `--quick` is gone).
+ *
+ * The RUNNER is `@omega.js/devkit/deploy-precheck` (one copy for every
+ * framework); this file is web's STEPS.
+ */
+const { runDeployPrecheck } = require('../../vendor/devkit/deploy-precheck.js');
+const { publishEnvSecrets } = require('../../github-secrets.js');
+
+/**
+ * The default steps, in order. Named so a test can hand its own recorder in
+ * and read back exactly which ones ran.
+ */
+const STEPS = [
+  {
+    name: 'push-secrets',
+    run: ({ projectDir, log, warn }) => publishEnvSecrets({ targetDir: projectDir, logger: { log, warn, error: warn } }),
+  },
+];
+
+/**
+ * @param {object} input
+ * @param {string} input.projectDir - The target root.
+ * @param {object} input.options - The parsed CLI options (`secrets: false` = opted out).
+ * @param {object} input.logger - `{ log, warn, error }`.
+ * @param {Array} [input.steps] - Injectable step list (tests).
+ * @returns {Promise<{ skipped: string }|{ ran: string[] }>} The steps that ran, or the opt-out marker.
+ */
+function deployPrecheck({ projectDir, options, logger, steps }) {
+  return runDeployPrecheck({ projectDir, options, logger, steps: steps || STEPS });
+}
+
+module.exports = { deployPrecheck, STEPS };

package/dist/commands/lib/ensure-target.js

@@ -0,0 +1,115 @@
+/**
+ * ensure-target — the LOCAL, idempotent scaffold every verb runs
+ * ([#675](https://github.com/Omega-JS-Stack/omega/issues/675)).
+ *
+ * `omega setup` used to own this half and nothing ran it for you, so a target
+ * drifted until someone remembered the command per target. It is retired: the
+ * "write it if missing" steps live here and dev/build/test/deploy each call it
+ * first, so every verb heals the tree on the way past.
+ *
+ * What it guarantees:
+ *
+ *   node version         a WARNING when the shell is older than the standard
+ *   scaffold defaults    the framework tree (marker merges for
+ *                        .gitignore/.env/AGENTS.md, omega.json5 seed, CI workflow)
+ *   package.json         the omega verb scripts + the engines.node floor
+ *
+ * Everything here is copy-if-missing, marker-merge or write-if-changed: a
+ * consumer file is never clobbered, and a run that changes nothing writes
+ * nothing. Anything that needs the network is NOT here — the secret
+ * publication `omega setup` also carried is a deploy precheck (deploy-precheck.js).
+ */
+const path = require('node:path');
+const jetpack = require('fs-jetpack');
+const { scaffoldDefaults, NODE_VERSION } = require('../../scaffold.js');
+const { assertScaffoldable } = require('../../vendor/devkit/scaffold-guard.js');
+
+const frameworkPackage = require('../../../package.json');
+
+// package.json scripts every consumer gets. Declared in the framework
+// manifest's `projectScripts` (sibling parity: backend/desktop/extension all
+// declare theirs there, and the manager's workspace walk reads it to heal a
+// fresh target before any verb has run). No `setup` entry: the verbs run
+// ensureTarget themselves (#675).
+const PROJECT_SCRIPTS = frameworkPackage.projectScripts;
+
+/**
+ * Sync the consumer manifest's omega scripts + engines floor. A manifest that
+ * already says all of it is not rewritten (#590 parity: identical content is
+ * not a write).
+ *
+ * @param {string} projectDir - The target root.
+ * @param {{ changed: string[] }} result - Collector.
+ */
+function scaffoldPackageJson(projectDir, result) {
+  const manifestPath = path.join(projectDir, 'package.json');
+  const exists = jetpack.exists(manifestPath);
+  const manifest = exists
+    ? JSON.parse(jetpack.read(manifestPath))
+    : { name: path.basename(projectDir), version: '1.0.0', private: true };
+
+  const before = JSON.stringify(manifest);
+  manifest.scripts = { ...manifest.scripts, ...PROJECT_SCRIPTS };
+  manifest.engines = { ...manifest.engines, node: `>=${NODE_VERSION}` };
+
+  if (JSON.stringify(manifest) === before && exists) return;
+
+  jetpack.write(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+  result.changed.push('package.json (scripts + engines.node)');
+}
+
+/**
+ * Make the target whole — idempotent, offline, and quiet when there is
+ * nothing to do.
+ *
+ * @param {object} [options]
+ * @param {string} [options.projectDir] - The target root (default: cwd).
+ * @param {function} [options.log] - Line logger (silent by default).
+ * @param {function} [options.warn] - Warning logger (silent by default).
+ * @returns {{ written: string[], merged: string[], changed: string[] }}
+ *   Target-relative paths per outcome — empty on a no-op run.
+ */
+function ensureTarget(options) {
+  options = options || {};
+  const projectDir = options.projectDir || process.cwd();
+  const log = options.log || (() => {});
+  const warn = options.warn || (() => {});
+  const result = { written: [], merged: [], changed: [] };
+
+  // The framework's own tree is not a consumer target. Running the framework's
+  // suite from packages/web puts the framework at the cwd, and a verb that
+  // scaffolds unconditionally would scatter the consumer defaults through the
+  // package. Refuse, quietly: this is a normal state, not a broken one.
+  if (jetpack.read(path.join(projectDir, 'package.json'), 'json')?.name === frameworkPackage.name) {
+    return result;
+  }
+
+  // A workspace ROOT is not a target either — and unlike the case above, landing
+  // there is an accident (a verb run from the wrong cwd), so it fails LOUD (#699).
+  assertScaffoldable(projectDir);
+
+  // ---- Node version check (warn only — the .nvmrc scaffolded below is the pin)
+  const nodeMajor = Number(process.versions.node.split('.')[0]);
+  if (nodeMajor < Number(NODE_VERSION)) {
+    warn(`Node ${process.versions.node} is older than the framework standard (v${NODE_VERSION}) — update .nvmrc/nvm`);
+  }
+
+  // ---- Scaffold defaults (copy-if-missing + marker merges)
+  const scaffolded = scaffoldDefaults({
+    outputDir: projectDir,
+    logger: { log: () => {}, warn: () => {}, error: () => {} },
+  });
+  result.written.push(...scaffolded.written);
+  result.merged.push(...scaffolded.merged);
+
+  // ---- Sync package.json scripts
+  scaffoldPackageJson(projectDir, result);
+
+  for (const [label, files] of [['Created', result.written], ['Merged', result.merged], ['Synced', result.changed]]) {
+    if (files.length > 0) log(`${label} ${files.join(', ')}`);
+  }
+
+  return result;
+}
+
+module.exports = { ensureTarget, PROJECT_SCRIPTS };

package/dist/commands/migrate.js

@@ -0,0 +1,86 @@
+/**
+ * `omega migrate` — convert a UJM (Jekyll) consumer to @omega.js/web in place:
+ * legacy configs → config/omega.json5, the codemod rule tables over src/**
+ * templates and consumer JS, the liquid-lint scan, legacy-file removal
+ * (Gemfile & co), the legacy test-harness report, and the undeclared-dependency
+ * report (#600).
+ *
+ * `omega migrate --check` runs the full pipeline in memory and prints the
+ * report without writing anything — the pre-flight for Phase-4 site waves.
+ */
+const Logger = require('../vendor/devkit/logger.js');
+const { runMigration } = require('../migrate/index.js');
+
+const logger = new Logger('migrate');
+
+module.exports = async function (options) {
+  const check = Boolean(options.check || options['dry-run']);
+  const root = process.cwd();
+
+  logger.log(`${check ? 'Checking' : 'Migrating'} ${root}`);
+  const report = runMigration(root, { check });
+
+  // ---- config
+  if (report.config && report.config.skipped) {
+    logger.log(`Config: already converted (${report.config.path}), skipping the conversion step`);
+  } else if (report.config) {
+    const verb = check ? 'would write' : 'wrote';
+    logger.log(`Config: ${verb} ${report.config.path} (from ${report.config.sources.join(' + ')})`);
+    for (const note of report.config.notes) logger.warn(`  note: ${note}`);
+    for (const error of report.config.validation || []) logger.error(`  validation: ${error}`);
+  }
+
+  // ---- codemod
+  const { files, totalEdits } = report.codemod;
+  logger.log(`Codemod: ${totalEdits} edit${totalEdits === 1 ? '' : 's'} across ${files.length} file${files.length === 1 ? '' : 's'}${check ? ' (preview)' : ''}`);
+  for (const file of files) {
+    const byRule = {};
+    for (const edit of file.edits) byRule[edit.rule] = (byRule[edit.rule] || 0) + 1;
+    const summary = Object.entries(byRule).map(([rule, count]) => `${rule}×${count}`).join(', ');
+    logger.log(`  ${file.path}: ${summary}`);
+  }
+
+  // ---- lint findings
+  const errors = report.lint.filter((finding) => finding.severity === 'error');
+  const warnings = report.lint.filter((finding) => finding.severity !== 'error');
+  if (report.lint.length > 0) {
+    logger.log(`Lint: ${errors.length} error${errors.length === 1 ? '' : 's'}, ${warnings.length} warning${warnings.length === 1 ? '' : 's'}`);
+    for (const finding of errors) logger.error(`  ${finding.file}:${finding.line} — ${finding.message}`);
+    for (const finding of warnings) logger.warn(`  ${finding.file}:${finding.line} — ${finding.message}`);
+  } else {
+    logger.log('Lint: clean');
+  }
+
+  // ---- legacy test harness (a silent `pass 0` otherwise)
+  if (report.legacyTests.length > 0) {
+    const count = report.legacyTests.length;
+    logger.warn(`Tests: ${count} legacy test file${count === 1 ? '' : 's'} will not be discovered — \`omega test\` runs \`node --test 'test/**/*.test.js'\`, which matches no \`test/<layer>/<name>.js\` and reports a green pass 0. Rename to \`*.test.js\` and port to node:test.`);
+    for (const rel of report.legacyTests) logger.warn(`  ${rel}`);
+  }
+
+  // ---- dependency resolution (#600): a bare require only the legacy FLAT
+  // install answered. Lazy ones load fine and 500 on the first real call.
+  if (report.bareRequires.length > 0) {
+    const count = report.bareRequires.length;
+    logger.warn(`Dependencies: ${count} bare require${count === 1 ? '' : 's'} of a package this project does not declare — the legacy flat install resolved them, an OMEGA install resolves them only by hoisting:`);
+    for (const entry of report.bareRequires) logger.warn(`  ${entry.file}:${entry.line} — \`${entry.module}\`: ${entry.fix}`);
+  }
+
+  // ---- removed files + fatal problems
+  for (const rel of report.removed) logger.log(`${check ? 'Would remove' : 'Removed'}: ${rel}`);
+  for (const error of report.errors) logger.error(error);
+
+  if (report.errors.length > 0) {
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!check) {
+    logger.log('');
+    logger.log('Next steps:');
+    logger.log('  1. Review the lint findings above (errors need manual ports)');
+    logger.log('  2. npx omega build   — scaffolds project files + syncs scripts, then builds');
+    logger.log('  3. npm run build     — verify the site builds');
+    logger.log('  4. Remove _site/ and any leftover Jekyll artifacts');
+  }
+};

package/dist/commands/purge.js

@@ -0,0 +1,31 @@
+/**
+ * `omega purge` — purge the site's Cloudflare zone cache (purge_everything).
+ * The UJM `uj cloudflare-purge` successor, hitting the Cloudflare API
+ * directly with the brand's own CLOUDFLARE_TOKEN (env cascade). Also runs
+ * automatically after `omega deploy --direct`, and the scaffolded CI
+ * workflow runs it after the gh-pages publish when the repo has the token
+ * secret. `--dry-run` resolves the zone and prints the plan.
+ */
+const Logger = require('../vendor/devkit/logger.js');
+const { consumerPaths, loadSiteData } = require('../consumer.js');
+const { purgeZoneCache } = require('../purge.js');
+
+const logger = new Logger('purge');
+
+module.exports = async function (options) {
+  options = options || {};
+  const paths = consumerPaths();
+  const config = loadSiteData(paths.root);
+
+  const result = await purgeZoneCache({ config, dryRun: Boolean(options.dryRun) });
+
+  if (result.status === 'skipped') {
+    logger.log(`Purge skipped — ${result.reason}`);
+  } else if (result.status === 'planned') {
+    logger.log(`[DRY RUN] Would purge Cloudflare zone ${result.zoneName || result.zone} (purge_everything)`);
+  } else {
+    logger.log(`Cloudflare cache purged (zone ${result.zoneName || result.zone})`);
+  }
+
+  return result;
+};

package/dist/commands/test.js

@@ -0,0 +1,237 @@
+/**
+ * `omega test` — C5-scoped test entry:
+ *   bare / `project:` / `brand:`      → production build + smoke verification,
+ *                                       then the consumer's own suite (node --test test/)
+ *   `framework:` / `omega:` / `web:`  → @omega.js/web's own suite
+ *   `full:`                           → both
+ *
+ * Smoke checks: pages rendered, 404.html (the guaranteed default page —
+ * consumers own their home page) carries the theme root, the manifest's main
+ * bundle exists on disk, every internal link the built pages emit resolves to
+ * something the same build wrote (#430), and the four built-output audit checks
+ * pass — page meta, anchor fragments, image alt, sitemap orphans (#468). The
+ * deeper 3-layer test framework (build/page/boot vs a real browser) is a later
+ * devkit adoption step.
+ */
+const fs = require('node:fs');
+const path = require('node:path');
+const { execSync } = require('node:child_process');
+const Logger = require('../vendor/devkit/logger.js');
+const attachLogFile = require('../vendor/devkit/attach-log-file.js');
+const { parseTestScope, isPathTargeted, noMatchMessage, noMatchExitCode, FRAMEWORK_IDS } = require('../vendor/devkit/test/scope.js');
+const { ensureTarget } = require('./lib/ensure-target.js');
+const { consumerPaths } = require('../consumer.js');
+const { checkDistLinks, loadExceptions, loadLinkExceptions, EXCEPTIONS_FILE } = require('../link-resolver.js');
+const { auditDist } = require('../dist-audit.js');
+
+const logger = new Logger('test');
+
+module.exports = async function (options) {
+  const paths = consumerPaths();
+
+  // Tee the whole run to <targetRoot>/logs/test.log (#197) — the file to grep
+  // after a failure instead of scrolling scrollback.
+  attachLogFile(path.join(paths.root, 'logs', 'test.log'));
+
+  // The local half of the retired `omega setup` (#675) — idempotent, offline,
+  // and quiet on a converged target.
+  ensureTarget({ projectDir: paths.root, log: (line) => logger.log(line), warn: (line) => logger.warn(line) });
+
+  // ---- C5 scope (bare = project only; the framework suite is explicit)
+  const targets = (options._ || []).slice(1);
+  const scope = parseTestScope(targets, {
+    frameworkAliases: FRAMEWORK_IDS['@omega.js/web'],
+  });
+  for (const bad of scope.invalid) {
+    logger.warn(`Unknown test scope prefix ignored: ${bad}`);
+  }
+
+  // A target that names a path and selects nothing is a typo, or a suite
+  // renamed out from under it: `node --test` treats a glob that matches
+  // nothing as a no-op and exits 0, so the run was silently green
+  // ([#814](https://github.com/Omega-JS-Stack/omega/issues/814)). Ahead of the
+  // production build below, so a typo costs a second, not a whole build.
+  if (isPathTargeted(scope) && selectedTestFiles(scope, {
+    frameworkRoot: path.resolve(__dirname, '../..'),
+    projectRoot: paths.root,
+  }).length === 0) {
+    logger.error(noMatchMessage(targets.join(' ')));
+    // Standalone that is 1. Inside a brand-root fan-out the manager forwarded
+    // ONE target to every target, so a distinct code lets it count this as a
+    // miss rather than a failure (#814).
+    process.exitCode = noMatchExitCode();
+    return;
+  }
+
+  // ---- Framework suite (framework:/omega:/web:/full:)
+  if (scope.sources.includes('framework')) {
+    const frameworkRoot = path.resolve(__dirname, '../..');
+    for (const { flags, target } of frameworkTestRuns(scope.filters.framework)) {
+      logger.log(`Running @omega.js/web framework tests (node --test ${flags}${target})`);
+      execSync(`node --test ${flags}${target}`, { stdio: 'inherit', cwd: frameworkRoot });
+    }
+  }
+
+  if (!scope.sources.includes('project')) {
+    return;
+  }
+
+  // ---- Production build (logFile: false — this run already owns logs/test.log)
+  const result = await require('./build.js')({ ...options, logFile: false });
+
+  // ---- Smoke checks over the output
+  const failures = [];
+
+  if (result.htmlCount < 1) {
+    failures.push('build produced no HTML pages');
+  }
+
+  const smokePage = path.join(paths.out, '404.html');
+  if (!fs.existsSync(smokePage)) {
+    failures.push('dist/404.html is missing (default pages did not render)');
+  } else if (!fs.readFileSync(smokePage, 'utf8').includes('data-theme-id')) {
+    failures.push('dist/404.html did not render through the theme root layout');
+  }
+
+  const mainBundle = result.manifest.js.main && path.join(paths.out, result.manifest.js.main.slice(1));
+  if (!mainBundle || !fs.existsSync(mainBundle)) {
+    failures.push('manifest js.main bundle is missing from dist/');
+  }
+
+  failures.push(...linkCheckFailures({ distDir: paths.out, targetRoot: paths.root }));
+  failures.push(...auditCheckFailures({ distDir: paths.out, targetRoot: paths.root }));
+
+  if (failures.length) {
+    throw new Error(`Smoke checks failed:\n  - ${failures.join('\n  - ')}`);
+  }
+  logger.log(`Smoke checks passed (${result.htmlCount} pages, every internal link resolves, every page audits clean)`);
+
+  // ---- Consumer test suite
+  const testDir = path.join(paths.root, 'test');
+  if (fs.existsSync(testDir)) {
+    const projectTests = projectTestArgs(scope.filters.project);
+    logger.log(`Running consumer tests (node --test ${projectTests})`);
+    execSync(`node --test ${projectTests}`, { stdio: 'inherit' });
+  }
+};
+
+/**
+ * The built-output link check as smoke-check lines ([#430](https://github.com/Omega-JS-Stack/omega/issues/430)).
+ *
+ * Both halves are failures: a link that resolves to nothing, and a declared
+ * exception that has started resolving (an exception standing over a fixed link
+ * masks the next regression at that URL, so the declared list has to shrink).
+ *
+ * @param {object} options
+ * @param {string} options.distDir - the build output
+ * @param {string} options.targetRoot - the consumer root (holds the exception list)
+ * @returns {string[]} one line per failure (empty = the check passed)
+ */
+function linkCheckFailures(options) {
+  const { offenders, stale } = checkDistLinks({
+    distDir: options.distDir,
+    exceptions: loadLinkExceptions(options.targetRoot),
+  });
+
+  return [
+    ...offenders.map((entry) => `dead internal link: ${entry} — add the page or fix the link`),
+    ...stale.map((entry) => `stale link exception in ${EXCEPTIONS_FILE}: ${entry} resolves now — drop it`),
+  ];
+}
+module.exports.linkCheckFailures = linkCheckFailures;
+
+/**
+ * The built-output audit checks as smoke-check lines ([#468](https://github.com/Omega-JS-Stack/omega/issues/468)):
+ * page meta, anchor fragments, image `alt` and sitemap orphans, over ONE walk
+ * of the same dist the link check reads.
+ *
+ * Same two halves as the link check: a page that fails a check, and a declared
+ * exception that has started passing (an exception left standing masks the next
+ * regression at that page, so the declared list has to shrink).
+ *
+ * @param {object} options
+ * @param {string} options.distDir - the build output
+ * @param {string} options.targetRoot - the consumer root (holds the exception list)
+ * @returns {string[]} one line per failure (empty = the checks passed)
+ */
+function auditCheckFailures(options) {
+  const audit = auditDist({
+    distDir: options.distDir,
+    exceptions: loadExceptions(options.targetRoot),
+  });
+
+  return [
+    ...audit.meta.offenders.map((entry) => `missing page meta: ${entry} — set it in the page's meta: frontmatter`),
+    ...audit.fragments.offenders.map((entry) => `dead anchor fragment: ${entry} — add the id to the page or fix the link`),
+    ...audit.alt.offenders.map((entry) => `image without alt: ${entry} — add alt (alt="" for a decorative image)`),
+    ...audit.sitemap.offenders.map((entry) => `page missing from sitemap.xml: ${entry} — a page kept out of the sitemap must also be noindex (meta.index: false, one decision per #564), or declare 'sitemap: true' for it in config/link-exceptions.json5`),
+    ...['meta', 'fragments', 'alt', 'sitemap'].flatMap((check) => audit[check].stale
+      .map((entry) => `stale ${check} exception in ${EXCEPTIONS_FILE}: ${entry} passes now — drop it`)),
+  ];
+}
+module.exports.auditCheckFailures = auditCheckFailures;
+
+/**
+ * The framework suite's two phases — the SAME split the package's own
+ * `npm test` runs (#344). `test/watch/` holds the rebuild-watching suites and
+ * runs alone, one file at a time: nine sibling test processes churning temp
+ * trees starve a watcher's FSEvents stream, and a starved watcher reads as a
+ * rebuild that never landed. A filter is applied to both phases — a glob that
+ * matches nothing is a no-op run, so naming a suite in either dir works.
+ * @param {string[]} filters - `web:<filter>` scope filters (empty = the lot)
+ * @returns {Array<{flags: string, target: string}>} the runs, in order
+ */
+function frameworkTestRuns(filters) {
+  const target = (dir) => (filters.length
+    ? filters.map((f) => `${dir}/${f.replace(/\.js$/, '')}*.test.js`).join(' ')
+    : `${dir}/*.test.js`);
+
+  return [
+    { flags: '', target: target('test') },
+    { flags: '--test-concurrency=1 ', target: target('test/watch') },
+  ];
+}
+module.exports.frameworkTestRuns = frameworkTestRuns;
+
+/**
+ * The test files a scoped run selects, resolved through the SAME globs the
+ * runs above hand to `node --test` (both framework phases plus the project
+ * lane), so a target that matches nothing can be told from one that matches
+ * ([#814](https://github.com/Omega-JS-Stack/omega/issues/814)). A filter that
+ * misses one framework phase and hits the other is a hit: the union is what
+ * the run gets.
+ *
+ * @param {object} scope - A parseTestScope() result
+ * @param {object} roots
+ * @param {string} roots.frameworkRoot - @omega.js/web's own package root
+ * @param {string} roots.projectRoot - the consumer target root
+ * @returns {string[]} Matched paths, relative to the root each glob ran in
+ */
+function selectedTestFiles(scope, roots) {
+  const patterns = [];
+
+  if (scope.sources.includes('framework')) {
+    patterns.push(...frameworkTestRuns(scope.filters.framework)
+      .flatMap((run) => run.target.split(' '))
+      .map((pattern) => ({ cwd: roots.frameworkRoot, pattern })));
+  }
+
+  if (scope.sources.includes('project')) {
+    // The project default carries the quotes the shell needs; a glob call does not.
+    patterns.push(...projectTestArgs(scope.filters.project).replace(/'/g, '').split(' ')
+      .map((pattern) => ({ cwd: roots.projectRoot, pattern })));
+  }
+
+  return patterns.flatMap(({ cwd, pattern }) => (fs.existsSync(cwd) ? fs.globSync(pattern, { cwd }) : []));
+}
+module.exports.selectedTestFiles = selectedTestFiles;
+
+// The default is a QUOTED glob node expands itself: a bare `test/` positional
+// is treated as a module on Node >= 22 (our engines floor), and macOS /bin/sh
+// would half-expand `**` if the shell saw it (#114).
+function projectTestArgs(filters) {
+  return filters.length
+    ? filters.map((f) => `test/${f.replace(/\.js$/, '')}*`).join(' ')
+    : `'test/**/*.test.js'`;
+}
+module.exports.projectTestArgs = projectTestArgs;

package/dist/commands/translate.js

@@ -0,0 +1,57 @@
+/**
+ * `omega translate` — translate the built site (dist/) into every language in
+ * `translation.languages`, using the committed per-string cache in
+ * translations/ and the configured provider (claude via local Claude Code by
+ * default; chatgpt via OPENAI_API_KEY). Run `omega build` first. This command
+ * OWNS live-LLM translation: build applies the committed cache only and
+ * skips cold pages with a warning (friction #24 decision).
+ *
+ * Env: OMEGA_TRANSLATE_ONLY=<route|file> limits the run to one page.
+ */
+const Logger = require('../vendor/devkit/logger.js');
+const { loadConfig, formatErrors } = require('../vendor/config/index.js');
+const { consumerPaths } = require('../consumer.js');
+const { translateSite } = require('../translate/index.js');
+const jetpack = require('fs-jetpack');
+
+const logger = new Logger('translate');
+
+module.exports = async function (options) {
+  const paths = consumerPaths();
+  const { config, errors } = loadConfig(paths.root, 'web');
+
+  if (errors && errors.length) {
+    throw new Error(`config/omega.json5 is invalid:\n${formatErrors(errors)}`);
+  }
+
+  if (!jetpack.exists(paths.out)) {
+    logger.error('No built site found (dist/) — run `omega build` first.');
+    process.exitCode = 1;
+    return;
+  }
+
+  const stats = await translateSite({
+    root: paths.root,
+    outDir: paths.out,
+    config,
+    logger,
+    only: process.env.OMEGA_TRANSLATE_ONLY,
+  });
+
+  if (stats.skipped) {
+    logger.log('Translation is disabled — set translation.languages in config/omega.json5 to enable it.');
+    return;
+  }
+
+  logger.log(`Translated ${stats.pages} pages → ${stats.languages.join(', ')} (${stats.newStrings} new strings, ${stats.cachedStrings} cached)`);
+
+  if (stats.usage.input || stats.usage.output) {
+    logger.log(`Provider tokens: ${stats.usage.input.toLocaleString()} in / ${stats.usage.output.toLocaleString()} out`);
+  }
+
+  if (stats.failures.length) {
+    logger.error(`${stats.failures.length} page-language pair(s) failed (skipped whole — no copy shipped):`);
+    stats.failures.forEach((failure) => logger.error(`  ${failure}`));
+    process.exitCode = 1;
+  }
+};

package/dist/commands/update.js

@@ -0,0 +1,22 @@
+/**
+ * `omega update` — dependency freshness report (npu-outdated semantics):
+ * installed/wanted/latest + patch/minor/major per dep, releases younger than
+ * --min-age days (default 7) QUARANTINED. `--apply` installs the
+ * non-quarantined, non-breaking set (`--major` opts into breaking) through
+ * npu when present. The whole verb is the shared devkit implementation.
+ */
+const Logger = require('../vendor/devkit/logger.js');
+const { runUpdate } = require('../vendor/devkit/update.js');
+
+const logger = new Logger('update');
+
+module.exports = async function (options) {
+  await runUpdate({
+    dir: process.cwd(),
+    apply: options.apply,
+    major: options.major,
+    minAge: options.minAge ?? options['min-age'],
+    forceFresh: options.forceFresh || options['force-fresh'],
+    logger,
+  });
+};

package/dist/commands/version.js

@@ -0,0 +1,11 @@
+/**
+ * `omega version` — print the framework version.
+ */
+const Logger = require('../vendor/devkit/logger.js');
+
+const logger = new Logger('version');
+const pkg = require('../../package.json');
+
+module.exports = async function (options) {
+  logger.log(pkg.version);
+};