stonyx 0.2.3-alpha.35 → 0.2.3-alpha.37

package/dist/modules.js

@@ -5,7 +5,7 @@
 import { readFile } from '@stonyx/utils/file';
 import { kebabCaseToCamelCase } from '@stonyx/utils/string';
 import { mergeObject } from '@stonyx/utils/object';
-import { importConfig } from './util/import-config.js';
+import { importModuleConfig } from './util/import-module-config.js';
 const modulePromises = {};
 // Configure module-specific logging
 function configureLog(chronicle, module, config) {
@@ -64,7 +64,10 @@ export default async function loadModules(config, rootPath, chronicle) {
         }
         try {
             // Load & Configure Async Modules
-            const moduleConfig = await importConfig(`${rootPath}/node_modules/${moduleName}/config/environment`);
+            // MODULE-OWNED: `.js` only, always. Routing this to the app-owned
+            // `importConfig` re-ships abofs/stonyx-orm#118 — Node refuses to
+            // type-strip inside `node_modules`. See abofs/stonyx#90.
+            const moduleConfig = await importModuleConfig(`${rootPath}/node_modules/${moduleName}/config/environment`);
             const module = kebabCaseToCamelCase(moduleName.split('/').pop() ?? moduleName);
             const userConfig = config[module] || {};
             const finalConfig = mergeObject(moduleConfig, userConfig);
@@ -77,7 +80,9 @@ export default async function loadModules(config, rootPath, chronicle) {
         }
         catch (error) {
             console.error(error);
-            throw new Error(`Stonyx modules with async loading must have a config/environment.js file with default configurations. Module "${moduleName}" failed to load.`);
+            throw new Error('Stonyx modules with async loading must ship a config/environment.js with default configurations. ' +
+                'Module configs resolve as .js only — never .ts, because Node refuses to type-strip inside node_modules. ' +
+                `Module "${moduleName}" failed to load.`);
         }
     }
     // Wait until all modules are initialized

package/dist/util/import-config.d.ts

@@ -1 +1,20 @@
+/**
+ * Resolve an APP-OWNED config — `<cwd>/config/environment`,
+ * `<rootPath>/test/config/environment` — as `{ts,js}`, preferring `.ts`.
+ * Mirrors `src/util/resolve-entry-point.ts`, which has resolved app-owned
+ * entry points this way since abofs/stonyx#67.
+ *
+ * These paths live in the consuming project's own tree, never inside
+ * `node_modules`, so they load under the app's own loader and Node's type
+ * stripping applies to them.
+ *
+ * MODULE-OWNED configs are NOT this function's business: see
+ * `importModuleConfig` in `./import-module-config.ts`, which resolves `.js`
+ * only. Routing `src/modules.ts` here re-ships abofs/stonyx-orm#118 — Node
+ * refuses to type-strip inside `node_modules`, so a `.ts` module config
+ * crashes every consumer at parse time. See abofs/stonyx#90.
+ *
+ * The "Config not found:" prefix is load-bearing: `src/main.ts` matches on it
+ * to tell an absent optional config from a real import failure.
+ */
 export declare function importConfig<T = unknown>(basePath: string): Promise<T>;

package/dist/util/import-config.js

@@ -1,10 +1,34 @@
 import { existsSync } from 'fs';
 import { pathToFileURL } from 'url';
+const EXTENSIONS = ['ts', 'js'];
+/**
+ * Resolve an APP-OWNED config — `<cwd>/config/environment`,
+ * `<rootPath>/test/config/environment` — as `{ts,js}`, preferring `.ts`.
+ * Mirrors `src/util/resolve-entry-point.ts`, which has resolved app-owned
+ * entry points this way since abofs/stonyx#67.
+ *
+ * These paths live in the consuming project's own tree, never inside
+ * `node_modules`, so they load under the app's own loader and Node's type
+ * stripping applies to them.
+ *
+ * MODULE-OWNED configs are NOT this function's business: see
+ * `importModuleConfig` in `./import-module-config.ts`, which resolves `.js`
+ * only. Routing `src/modules.ts` here re-ships abofs/stonyx-orm#118 — Node
+ * refuses to type-strip inside `node_modules`, so a `.ts` module config
+ * crashes every consumer at parse time. See abofs/stonyx#90.
+ *
+ * The "Config not found:" prefix is load-bearing: `src/main.ts` matches on it
+ * to tell an absent optional config from a real import failure.
+ */
 export async function importConfig(basePath) {
-    const path = `${basePath}.js`;
-    if (!existsSync(path)) {
-        throw new Error(`Config not found: ${path}`);
+    const matches = EXTENSIONS.filter(ext => existsSync(`${basePath}.${ext}`));
+    if (matches.length === 0) {
+        throw new Error(`Config not found: ${basePath}.{ts,js}`);
     }
+    if (matches.length > 1) {
+        console.warn(`Warning: both ${basePath}.ts and ${basePath}.js exist. Using .ts — delete the .js to silence this warning (it is likely a stale compiled artifact or postinstall stub).`);
+    }
+    const path = `${basePath}.${matches[0]}`;
     const mod = await import(pathToFileURL(path).href);
     return mod.default;
 }

package/dist/util/import-module-config.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Resolve a MODULE-OWNED config — `node_modules/<mod>/config/environment` — as
+ * `.js` ONLY. There is no `.ts` fallback and there must never be one.
+ *
+ * Node's type-strip loader refuses to process `.ts` files inside
+ * `node_modules`, so a `@stonyx/*` module that ships `config/environment.ts`
+ * crashes every consumer at parse time. That is abofs/stonyx-orm#118, the P0
+ * `4c80c87` was written to prevent, and this function preserves `4c80c87`'s
+ * behaviour byte-for-byte — including the exact `Config not found: <base>.js`
+ * message, which `test/unit/import-config-test.ts` pins as a regression guard.
+ *
+ * App-owned configs resolve `{ts,js}` instead: see `importConfig` in
+ * `./import-config.ts`. The boundary is OWNERSHIP, not extension — see
+ * abofs/stonyx#90 and `docs/conventions/framework-modules.md`.
+ */
+export declare function importModuleConfig<T = unknown>(basePath: string): Promise<T>;

package/dist/util/import-module-config.js

@@ -0,0 +1,25 @@
+import { existsSync } from 'fs';
+import { pathToFileURL } from 'url';
+/**
+ * Resolve a MODULE-OWNED config — `node_modules/<mod>/config/environment` — as
+ * `.js` ONLY. There is no `.ts` fallback and there must never be one.
+ *
+ * Node's type-strip loader refuses to process `.ts` files inside
+ * `node_modules`, so a `@stonyx/*` module that ships `config/environment.ts`
+ * crashes every consumer at parse time. That is abofs/stonyx-orm#118, the P0
+ * `4c80c87` was written to prevent, and this function preserves `4c80c87`'s
+ * behaviour byte-for-byte — including the exact `Config not found: <base>.js`
+ * message, which `test/unit/import-config-test.ts` pins as a regression guard.
+ *
+ * App-owned configs resolve `{ts,js}` instead: see `importConfig` in
+ * `./import-config.ts`. The boundary is OWNERSHIP, not extension — see
+ * abofs/stonyx#90 and `docs/conventions/framework-modules.md`.
+ */
+export async function importModuleConfig(basePath) {
+    const path = `${basePath}.js`;
+    if (!existsSync(path)) {
+        throw new Error(`Config not found: ${path}`);
+    }
+    const mod = await import(pathToFileURL(path).href);
+    return mod.default;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stonyx",
-  "version": "0.2.3-alpha.35",
+  "version": "0.2.3-alpha.37",
   "description": "Base stonyx framework module",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
@@ -70,6 +70,7 @@
     "start": "node .",
     "test": "pnpm build && node --import tsx node_modules/qunit/bin/qunit.js 'test/**/*-test.ts'",
     "test:acceptance": "STONYX_ACCEPTANCE=1 node --import tsx node_modules/qunit/bin/qunit.js 'test/acceptance/**/*-test.ts'",
+    "test:acceptance:ratchet": "node scripts/acceptance-ratchet.js",
     "error": "echo \"Error: no error handling\" && exit 1",
     "postinstall": "node scripts/postinstall.js"
   }

package/scripts/acceptance-ratchet.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+/*
+ * Expected-failures ratchet for the fresh-clone scaffold acceptance harness.
+ *
+ * The harness (abofs/stonyx#89) is RED BY DESIGN until #90, #91 and #92 land.
+ * Running it bare in CI produces a permanently-red check, which is the highest-
+ * leverage place for a vacuous check to hide: nobody re-examines a check that is
+ * always red, and it cannot signal a NEW failure because it is already failing.
+ *
+ * This wrapper diffs the observed red set against
+ * `test/acceptance/expected-failures.json` IN BOTH DIRECTIONS:
+ *
+ *   green today  — the known reds are the baseline, so nobody is trained to
+ *                  ignore a red check;
+ *   red on new   — an unlisted failure is a regression;
+ *   red on fixed — an assertion that starts PASSING while still listed fails the
+ *                  job, which mechanically forces each of #90-#92 to shrink the
+ *                  baseline in its own PR.
+ *
+ * Usage: pnpm test:acceptance:ratchet
+ */
+import { spawn } from 'child_process';
+import { readFileSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const BASELINE = path.join(REPO_ROOT, 'test', 'acceptance', 'expected-failures.json');
+
+// The control flags hand-patch the generated project, so a controlled run says
+// nothing about the baseline. Refuse rather than silently ratchet against it.
+if (process.env.STONYX_ACCEPTANCE_CONTROL) {
+  console.error(
+    'STONYX_ACCEPTANCE_CONTROL is set. The ratchet compares an UNMODIFIED run against the\n' +
+    'baseline; a control run hand-patches the generated project and would falsify it.\n' +
+    'Run `pnpm test:acceptance` directly to exercise a control.'
+  );
+  process.exit(2);
+}
+
+const baseline = JSON.parse(readFileSync(BASELINE, 'utf8'));
+const modulePrefix = `${baseline.module} > `;
+const expected = new Map(baseline.expectedFailures.map(entry => [entry.name, entry.issue]));
+
+const child = spawn(
+  process.execPath,
+  ['--import', 'tsx', 'node_modules/qunit/bin/qunit.js', 'test/acceptance/**/*-test.ts'],
+  { cwd: REPO_ROOT, env: { ...process.env, STONYX_ACCEPTANCE: '1' }, stdio: ['inherit', 'pipe', 'inherit'] }
+);
+
+let tap = '';
+
+child.stdout.on('data', chunk => {
+  tap += String(chunk);
+  process.stdout.write(chunk);
+});
+
+child.on('close', () => {
+  const observed = new Map();
+
+  for (const line of tap.split('\n')) {
+    const match = /^(not ok|ok) \d+ (.*)$/.exec(line.trim());
+    if (!match) continue;
+
+    const name = match[2].startsWith(modulePrefix) ? match[2].slice(modulePrefix.length) : match[2];
+    observed.set(name, match[1] === 'ok');
+  }
+
+  if (observed.size === 0) {
+    fail(['The acceptance run produced no TAP assertions at all. This is a harness or setup failure, not a result.']);
+  }
+
+  const problems = [];
+
+  for (const [name, passed] of observed) {
+    if (!passed && !expected.has(name)) {
+      problems.push(`NEW FAILURE (not in the baseline): ${name}\n    A regression, or an assertion that needs an owning issue before it is baselined.`);
+    }
+
+    if (passed && expected.has(name)) {
+      problems.push(
+        `NOW PASSING but still baselined (issue #${expected.get(name)}): ${name}\n` +
+        '    Delete this entry from test/acceptance/expected-failures.json in the PR that fixed it.'
+      );
+    }
+  }
+
+  for (const name of expected.keys()) {
+    if (!observed.has(name)) {
+      problems.push(`BASELINED ASSERTION NOT FOUND: ${name}\n    It was renamed or removed. Update the baseline in the same PR.`);
+    }
+  }
+
+  if (problems.length) fail(problems);
+
+  const stillRed = [...expected.keys()].filter(name => observed.get(name) === false);
+
+  console.log(`\n# acceptance ratchet: OK — ${observed.size} assertions, ${stillRed.length} expected failures, 0 unexpected.`);
+  for (const name of stillRed) console.log(`#   expected red (#${expected.get(name)}): ${name}`);
+  process.exit(0);
+});
+
+function fail(problems) {
+  console.error('\n# acceptance ratchet: FAILED\n');
+  for (const problem of problems) console.error(`  - ${problem}\n`);
+  console.error('See test/acceptance/expected-failures.json and docs/testing.md.');
+  process.exit(1);
+}