@beignet/cli 0.0.50 → 0.0.52

package/dist/templates/testing.js

@@ -1,3 +1,4 @@
+import { appTestFilePattern, configuredTestDirectoryPathKeys, configuredTestFilePathKeys, defaultAppTestRoots, } from "../test-discovery.js";
 export const testHelperTemplateFile = {
     path: "lib/beignet-test.ts",
     content: `import assert from "node:assert/strict";
@@ -405,16 +406,9 @@ import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 
-const defaultTestRoots = [
-  "app",
-  "features",
-  "infra",
-  "lib",
-  "ports",
-  "server",
-  "tests",
-  "src/tests",
-];
+const defaultTestRoots = ${JSON.stringify(defaultAppTestRoots, null, 2)};
+const configuredTestDirectoryPathKeys = ${JSON.stringify(configuredTestDirectoryPathKeys)};
+const configuredTestFilePathKeys = ${JSON.stringify(configuredTestFilePathKeys)};
 const ignoredDirectories = new Set([
   ".beignet-local",
   ".git",
@@ -424,7 +418,7 @@ const ignoredDirectories = new Set([
   "dist",
   "node_modules",
 ]);
-const testFilePattern = /\\.(test|spec)\\.[cm]?[tj]sx?$/;
+const testFilePattern = /${appTestFilePattern.source}/;
 
 const configFileNames = [
   "beignet.config.ts",
@@ -529,14 +523,8 @@ async function configuredRoots(cwd: string): Promise<string[]> {
   }
   const paths = isObjectRecord(config.paths) ? config.paths : {};
   return [
-    paths.tests,
-    paths.features,
-    parentPath(paths.routes),
-    parentPath(paths.server),
-    parentPath(paths.portWiring),
-    parentPath(paths.ports),
-    parentPath(paths.useCaseBuilder),
-    parentPath(paths.routesBuilder),
+    ...configuredTestDirectoryPathKeys.map((key) => paths[key]),
+    ...configuredTestFilePathKeys.map((key) => parentPath(paths[key])),
   ].filter((root): root is string => Boolean(root) && root !== ".");
 }
 

package/dist/templates/testing.js.map

@@ -1 +1 @@
-{"version":3,"file":"testing.js","sourceRoot":"","sources":["../../src/templates/testing.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,sBAAsB,GAAiB;IAClD,IAAI,EAAE,qBAAqB;IAC3B,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4YV;CACA,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAiB;IAClD,IAAI,EAAE,4BAA4B;IAClC,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkKV;CACA,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAmB;IACtD,sBAAsB;IACtB,sBAAsB;CACvB,CAAC"}
+{"version":3,"file":"testing.js","sourceRoot":"","sources":["../../src/templates/testing.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,+BAA+B,EAC/B,0BAA0B,EAC1B,mBAAmB,GACpB,MAAM,sBAAsB,CAAC;AAG9B,MAAM,CAAC,MAAM,sBAAsB,GAAiB;IAClD,IAAI,EAAE,qBAAqB;IAC3B,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4YV;CACA,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAiB;IAClD,IAAI,EAAE,4BAA4B;IAClC,OAAO,EAAE;;;;;2BAKgB,IAAI,CAAC,SAAS,CAAC,mBAAmB,EAAE,IAAI,EAAE,CAAC,CAAC;0CAC7B,IAAI,CAAC,SAAS,CAAC,+BAA+B,CAAC;qCACpD,IAAI,CAAC,SAAS,CAAC,0BAA0B,CAAC;;;;;;;;;;2BAUpD,kBAAkB,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoInD;CACA,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAmB;IACtD,sBAAsB;IACtB,sBAAsB;CACvB,CAAC"}

package/dist/test-discovery.d.ts

@@ -0,0 +1,9 @@
+import { type BeignetPaths } from "./config.js";
+export declare const defaultAppTestRoots: readonly ["app", "features", "infra", "lib", "ports", "server", "tests", "src/tests"];
+export declare const configuredTestDirectoryPathKeys: readonly ["tests", "features"];
+export declare const configuredTestFilePathKeys: readonly ["routes", "server", "portWiring", "ports", "useCaseBuilder", "routesBuilder"];
+export declare const appTestFilePattern: RegExp;
+export declare function appTestRoots(paths: BeignetPaths): string[];
+export declare function isAppTestFile(file: string): boolean;
+export declare function isWithinAppTestRoots(file: string, roots: readonly string[]): boolean;
+//# sourceMappingURL=test-discovery.d.ts.map

package/dist/test-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-discovery.d.ts","sourceRoot":"","sources":["../src/test-discovery.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,YAAY,EAAiB,MAAM,aAAa,CAAC;AAE/D,eAAO,MAAM,mBAAmB,uFAStB,CAAC;AAEX,eAAO,MAAM,+BAA+B,gCAGQ,CAAC;AAErD,eAAO,MAAM,0BAA0B,yFAOa,CAAC;AAErD,eAAO,MAAM,kBAAkB,QAAiC,CAAC;AAEjE,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,EAAE,CAW1D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,OAAO,CAET"}

package/dist/test-discovery.js

@@ -0,0 +1,40 @@
+import path from "node:path";
+import { directoryPath } from "./config.js";
+export const defaultAppTestRoots = [
+    "app",
+    "features",
+    "infra",
+    "lib",
+    "ports",
+    "server",
+    "tests",
+    "src/tests",
+];
+export const configuredTestDirectoryPathKeys = [
+    "tests",
+    "features",
+];
+export const configuredTestFilePathKeys = [
+    "routes",
+    "server",
+    "portWiring",
+    "ports",
+    "useCaseBuilder",
+    "routesBuilder",
+];
+export const appTestFilePattern = /\.(test|spec)\.[cm]?[jt]sx?$/;
+export function appTestRoots(paths) {
+    const roots = [
+        ...defaultAppTestRoots,
+        ...configuredTestDirectoryPathKeys.map((key) => paths[key]),
+        ...configuredTestFilePathKeys.map((key) => directoryPath(path.posix.dirname(paths[key]))),
+    ];
+    return Array.from(new Set(roots.map(directoryPath).filter((root) => root && root !== ".")));
+}
+export function isAppTestFile(file) {
+    return appTestFilePattern.test(file);
+}
+export function isWithinAppTestRoots(file, roots) {
+    return roots.some((root) => file.startsWith(`${root}/`));
+}
+//# sourceMappingURL=test-discovery.js.map

package/dist/test-discovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-discovery.js","sourceRoot":"","sources":["../src/test-discovery.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAqB,aAAa,EAAE,MAAM,aAAa,CAAC;AAE/D,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,KAAK;IACL,UAAU;IACV,OAAO;IACP,KAAK;IACL,OAAO;IACP,QAAQ;IACR,OAAO;IACP,WAAW;CACH,CAAC;AAEX,MAAM,CAAC,MAAM,+BAA+B,GAAG;IAC7C,OAAO;IACP,UAAU;CACwC,CAAC;AAErD,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACxC,QAAQ;IACR,QAAQ;IACR,YAAY;IACZ,OAAO;IACP,gBAAgB;IAChB,eAAe;CACmC,CAAC;AAErD,MAAM,CAAC,MAAM,kBAAkB,GAAG,8BAA8B,CAAC;AAEjE,MAAM,UAAU,YAAY,CAAC,KAAmB;IAC9C,MAAM,KAAK,GAAG;QACZ,GAAG,mBAAmB;QACtB,GAAG,+BAA+B,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC3D,GAAG,0BAA0B,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CACxC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAC9C;KACF,CAAC;IACF,OAAO,KAAK,CAAC,IAAI,CACf,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,IAAI,IAAI,KAAK,GAAG,CAAC,CAAC,CACzE,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,OAAO,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACvC,CAAC;AAED,MAAM,UAAU,oBAAoB,CAClC,IAAY,EACZ,KAAwB;IAExB,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC;AAC3D,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beignet/cli",
-  "version": "0.0.50",
+  "version": "0.0.52",
   "type": "module",
   "description": "CLI for creating and maintaining Beignet apps.",
   "main": "./dist/lib.js",
@@ -33,8 +33,8 @@
     "prepack": "bun run build",
     "dev": "tsc --watch",
     "clean": "rm -rf dist coverage .turbo",
-    "test": "bun test",
-    "test:coverage": "bun test --coverage",
+    "test": "bun test --parallel=2",
+    "test:coverage": "bun test --parallel=2 --coverage",
     "lint": "biome check ."
   },
   "keywords": [
@@ -64,18 +64,20 @@
   },
   "devDependencies": {
     "@modelcontextprotocol/client": "^2.0.0",
-    "@types/bun": "^1.3.13",
+    "@types/bun": "^1.4.0",
     "@types/node": "^22.0.0",
+    "@types/semver": "^7.8.0",
     "next-themes": "^0.4.6",
     "tsx": "^4.22.4"
   },
   "dependencies": {
-    "@beignet/core": "^0.0.50",
+    "@beignet/core": "^0.0.52",
     "@clack/prompts": "^1.5.1",
     "@modelcontextprotocol/server": "^2.0.0",
     "@stricli/core": "^1.2.7",
     "diff": "^8.0.4",
     "jiti": "^2.7.0",
+    "semver": "^7.8.5",
     "typescript": "^5.3.0",
     "zod": "^4.2.0"
   }

package/skills/app-structure/SKILL.md

@@ -8,8 +8,8 @@ description: "Maintain Beignet app structure with @beignet/cli: deterministic ap
 Use this skill when working with Beignet apps through `@beignet/cli`. Prefer
 generators and validation commands before hand-editing framework wiring.
 
-Beignet apps require Node.js 22.12 or newer. Bun 1.3.14 or newer is supported
-for Beignet commands.
+Beignet apps require Node.js 22.12 or newer. Bun is optional; npm, pnpm, Yarn,
+and Bun can run Beignet commands.
 
 ## Starter Sources
 
@@ -53,6 +53,12 @@ beignet make upload issues.attachment --ui
 Generators place files under the owning feature, update central registries
 when possible, and keep `doctor` clean.
 
+Event schemas must output canonical JSON transport data. Use null, strings,
+finite numbers, booleans, arrays, and plain objects. Keep validation
+deterministic and side-effect-free, keep transforms idempotent, and represent
+timestamps as strings or numbers rather than `Date` objects.
+Beignet rejects payloads that would change when decoded and validated again.
+
 Use `make upload --ui` in full-stack apps when the upload should include a
 shared client/server constraint manifest, typed React upload client, uploader,
 and component test. Omit `--ui` for API-only or backend-only workflows.
@@ -174,6 +180,15 @@ Start unfamiliar app work with `beignet map`. Its human output summarizes each
 feature; `beignet map --json` returns the versioned graph with source evidence,
 registration status, doctor/lint findings, and unresolved references. Use
 `--feature <name>` or `--kind route,use-case,event` to bound agent context.
+The graph analyzes TypeScript (`.ts`, `.tsx`, `.mts`, and `.cts`) and
+JavaScript (`.js`, `.jsx`, `.mjs`, and `.cjs`) source. Statically recognizable
+Beignet declarations using ES module exports become normal concept nodes, and
+CommonJS `require()` calls contribute dependency evidence. Test/spec files
+under canonical and configured app test roots become test nodes.
+Feature tests keep feature ownership; adjacent app, infra, server, and
+top-level tests remain app-level nodes and can surface as reverse-import
+consumers in changed mode. Treat those links as impact evidence, not proof of
+behavioral coverage.
 After editing inside a Git worktree, use `beignet map --changed` to inspect
 directly changed concepts, reverse imports, one-hop semantic consumers, feature
 context, and unresolved evidence before running `beignet check`. The report
@@ -184,8 +199,16 @@ and does not prove correctness. Recognized guide files and root
 documentation-directory content stay non-impacting; other `.mdx` and `.txt`
 paths remain application changes. Changed files with no mapped concept appear
 as explicit gaps.
-The graph resolves local modules with the full TypeScript `baseUrl` and `paths`
-configuration. Treat `local_import_unresolved` and
+
+`beignet check` fingerprints Git source before and after the full validation
+loop. Treat `provenance.status: "stale"` as a failed result even when every
+individual step passed, and rerun against the resulting source. Outside Git,
+the same checks run with provenance marked unavailable; report that limitation
+instead of describing the result as source-current.
+
+The graph resolves local modules with the full `baseUrl` and `paths`
+configuration from `tsconfig.json`, or `jsconfig.json` when no TypeScript
+config exists. Treat `local_import_unresolved` and
 `contract_declaration_unresolved` as real blind spots to fix, not absent
 relationships. This includes direct and contract-group declarations whose
 method, path, or group prefix is dynamic. Local fluent-builder aliases and
@@ -208,8 +231,8 @@ the declaration without parsing the diagnostic message.
   and feature-root helpers must not depend back on agent adapters
 - seeds should compose factories and context ports rather than concrete infra,
   providers, UI, or runtime composition
-- TypeScript imports, re-exports, `require()`, import assignments, and literal
-  dynamic imports all participate in the same graph
+- JavaScript and TypeScript imports, re-exports, `require()`, import
+  assignments, and literal dynamic imports all participate in the same graph
 - feature-root helpers are classified and followed transitively, so they cannot
   hide a forbidden dependency; computed module references in constrained layers
   fail when lint cannot verify their destination
@@ -274,7 +297,9 @@ names, source selectors, and applicable aliases. `check` accepts optional
 `{ preflight?: boolean, preflightConnect?: boolean, connectTimeoutMs?: number, timeoutMs?: number }`.
 Connected preflight adds migration status and dependency health checks. Check
 bounds failure output, cancels the active script with the MCP request, and
-returns the same versioned result as `beignet check --json`. It does not apply
+returns the same versioned result as `beignet check --json`, including
+starting and ending source provenance. An ending fingerprint that differs from
+the baseline makes the result stale and unsuccessful. It does not apply
 Beignet fixes, but app package scripts retain their normal side effects. The
 target package must declare `@beignet/core`, `@beignet/next`, or `@beignet/web`
 as a runtime dependency. The root must also contain `app-context.ts` or
@@ -293,9 +318,11 @@ and inspection failures use another non-zero exit. `task_run` and
 `schedule_run` execute registered app workflows. Use `outbox_inspect` for
 read-only `list` and `show`, and `outbox_run` for state-changing `drain`,
 `requeue`, `purge`, and `prune`; purge and prune support `dryRun`. Operational
-tools isolate app code, bound structured results, and stop the complete process
-tree on request cancellation or timeout. Optional operational `module`
-overrides must stay inside the app root where the MCP server started.
+drains with nonzero `settlementFailed` or `leaseLost` return the complete JSON
+report as an error result. Parallel delivery is opt-in and unordered.
+Operational tools isolate app code, bound structured results, and stop the
+complete process tree on request cancellation or timeout. Optional operational
+`module` overrides must stay inside the app root where the MCP server started.
 Cancellation and timeouts cannot roll back side effects that already
 completed. Inspect app state before retrying an interrupted operation or one
 that reports a cleanup failure. `doctor`, `lint`, and their JSON output match

package/src/analysis/layers.ts

@@ -5,6 +5,8 @@ import {
   normalizePath,
   type ResolvedBeignetConfig,
 } from "../config.js";
+import { isAppTestFile } from "../test-discovery.js";
+import { stripSourceFileExtension } from "./source-files.js";
 
 export type SourceLayer =
   | "app"
@@ -190,7 +192,7 @@ export function canonicalFeatureLayerPath(
 
 function isTestSourceFile(segment: string, rest: string[]): boolean {
   const fileName = rest.at(-1) ?? segment;
-  return /\.(?:test|spec)\.(?:ts|tsx|mts|cts)$/.test(fileName);
+  return isAppTestFile(fileName);
 }
 
 function featureDirectoryConvention(
@@ -233,7 +235,7 @@ function normalizeLayerSegment(segment: string): string {
 }
 
 function stripKnownExtension(filePath: string): string {
-  return filePath.replace(/\.(c|m)?tsx?$/, "");
+  return stripSourceFileExtension(filePath);
 }
 
 function isTestPath(filePath: string): boolean {

package/src/analysis/port-wiring.ts

@@ -2,6 +2,7 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import ts from "typescript";
 import type { ResolvedBeignetConfig } from "../config.js";
+import { sourceFileScriptKind } from "./source-files.js";
 import type { AnalysisWorkspace } from "./workspace.js";
 
 type PortAnalysisWorkspace = Pick<
@@ -241,7 +242,7 @@ export async function analyzePortWiringFiles(options: {
         await readFile(path.join(options.targetDir, file), "utf8"),
         ts.ScriptTarget.Latest,
         true,
-        file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+        sourceFileScriptKind(file),
       );
       sourceFiles.set(file, sourceFile);
       return sourceFile;

package/src/analysis/source-files.ts

@@ -0,0 +1,61 @@
+import path from "node:path";
+import ts from "typescript";
+
+export const typescriptAnalysisSourceFileExtensions = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+] as const;
+
+export const javascriptAnalysisSourceFileExtensions = [
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+] as const;
+
+export const analysisSourceFileExtensions = [
+  ...typescriptAnalysisSourceFileExtensions,
+  ...javascriptAnalysisSourceFileExtensions,
+] as const;
+
+const sourceFileExtensions = new Set<string>(analysisSourceFileExtensions);
+const javascriptSourceFileExtensions = new Set<string>(
+  javascriptAnalysisSourceFileExtensions,
+);
+const declarationFilePattern = /\.d\.(?:ts|mts|cts)$/;
+
+/** Whether an extension belongs to the JavaScript/TypeScript source family. */
+export function isAnalysisSourceFileExtension(extension: string): boolean {
+  return sourceFileExtensions.has(extension);
+}
+
+/** Whether a project file can participate in Beignet source analysis. */
+export function isAnalysisSourceFile(file: string): boolean {
+  return (
+    isAnalysisSourceFileExtension(path.posix.extname(file)) &&
+    !declarationFilePattern.test(file)
+  );
+}
+
+/** Remove a JavaScript or TypeScript source extension from a path. */
+export function stripSourceFileExtension(file: string): string {
+  const extension = path.posix.extname(file);
+  return isAnalysisSourceFileExtension(extension)
+    ? file.slice(0, -extension.length)
+    : file;
+}
+
+/** Whether a source file uses JavaScript rather than TypeScript syntax. */
+export function isJavaScriptSourceFile(file: string): boolean {
+  return javascriptSourceFileExtensions.has(path.posix.extname(file));
+}
+
+/** Select the TypeScript parser mode for a JavaScript or TypeScript file. */
+export function sourceFileScriptKind(file: string): ts.ScriptKind {
+  if (file.endsWith(".tsx")) return ts.ScriptKind.TSX;
+  if (file.endsWith(".jsx")) return ts.ScriptKind.JSX;
+  if (isJavaScriptSourceFile(file)) return ts.ScriptKind.JS;
+  return ts.ScriptKind.TS;
+}

package/src/analysis/workspace.ts

@@ -8,6 +8,10 @@ import {
   type ResolvedBeignetConfig,
   resolveConfig,
 } from "../config.js";
+import {
+  isAnalysisSourceFileExtension,
+  sourceFileScriptKind,
+} from "./source-files.js";
 
 const ignoredDirectoryNames = new Set([
   ".git",
@@ -84,7 +88,7 @@ export async function createAnalysisWorkspace(
         await readSource(file),
         ts.ScriptTarget.Latest,
         true,
-        scriptKind(file),
+        sourceFileScriptKind(file),
       );
       sourceFiles.set(file, sourceFile);
       return sourceFile;
@@ -208,12 +212,7 @@ export function isLocalModuleSpecifier(
   importPath: string,
 ): boolean {
   const extension = path.posix.extname(importPath);
-  if (
-    extension &&
-    ![".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"].includes(
-      extension,
-    )
-  ) {
+  if (extension && !isAnalysisSourceFileExtension(extension)) {
     return false;
   }
   if (importPath.startsWith(".")) return true;
@@ -298,28 +297,32 @@ function resolveCompilerConfiguration(targetDir: string): {
   compilerOptions: ts.CompilerOptions;
 } {
   const compilerConfigFiles = new Set<string>();
-  const configPath = path.join(targetDir, "tsconfig.json");
-  const compilerOptions =
-    ts.getParsedCommandLineOfConfigFile(
-      configPath,
-      {},
-      {
-        ...ts.sys,
-        readFile(file) {
-          compilerConfigFiles.add(path.resolve(file));
-          return ts.sys.readFile(file);
+  const configPath = ["tsconfig.json", "jsconfig.json"]
+    .map((file) => path.join(targetDir, file))
+    .find(ts.sys.fileExists);
+  const compilerOptions = configPath
+    ? (ts.getParsedCommandLineOfConfigFile(
+        configPath,
+        {},
+        {
+          ...ts.sys,
+          readFile(file) {
+            compilerConfigFiles.add(path.resolve(file));
+            return ts.sys.readFile(file);
+          },
+          onUnRecoverableConfigFileDiagnostic: () => {},
         },
-        onUnRecoverableConfigFileDiagnostic: () => {},
-      },
-    )?.options ?? {};
+      )?.options ?? {})
+    : {};
+  const analysisOptions = { ...compilerOptions, allowJs: true };
 
   return {
     compilerConfigFiles: [...compilerConfigFiles].sort(),
-    compilerOptions: compilerOptions.paths
-      ? compilerOptions
+    compilerOptions: analysisOptions.paths
+      ? analysisOptions
       : {
-          ...compilerOptions,
-          baseUrl: compilerOptions.baseUrl ?? targetDir,
+          ...analysisOptions,
+          baseUrl: analysisOptions.baseUrl ?? targetDir,
           paths: {
             "@/*": ["*"],
           },
@@ -338,10 +341,3 @@ function compilerPathsBase(
     compilerOptions.baseUrl ?? optionsWithPathBase.pathsBasePath ?? targetDir
   );
 }
-
-function scriptKind(file: string): ts.ScriptKind {
-  if (file.endsWith(".tsx")) return ts.ScriptKind.TSX;
-  if (file.endsWith(".jsx")) return ts.ScriptKind.JSX;
-  if (file.endsWith(".js") || file.endsWith(".mjs")) return ts.ScriptKind.JS;
-  return ts.ScriptKind.TS;
-}

package/src/app-map-changes.ts

@@ -1,5 +1,9 @@
 import { readFile, realpath } from "node:fs/promises";
 import path from "node:path";
+import {
+  isAnalysisSourceFile,
+  stripSourceFileExtension,
+} from "./analysis/source-files.js";
 import {
   type LocalImportReference,
   localImportReferences,
@@ -794,7 +798,7 @@ async function addImportConsumers(args: {
       reference: LocalImportReference;
     }>
   >();
-  const sourceFiles = args.workspace.files.filter(isSourceFile);
+  const sourceFiles = args.workspace.files.filter(isAnalysisSourceFile);
   await Promise.all(
     sourceFiles.map(async (file) => {
       for (const reference of await localImportReferences(
@@ -826,7 +830,9 @@ async function addImportConsumers(args: {
     );
   }
 
-  for (const change of args.changes.filter((item) => isSourceFile(item.file))) {
+  for (const change of args.changes.filter((item) =>
+    isAnalysisSourceFile(item.file),
+  )) {
     const queue: Array<{
       confidence: "exact" | "partial";
       depth: number;
@@ -1002,7 +1008,7 @@ function addUnmappedChangeGaps(args: {
     const represented = reasons.some(
       (reason) => reason.changedFile === change.repositoryPath,
     );
-    const sourceFile = isSourceFile(change.file);
+    const sourceFile = isAnalysisSourceFile(change.file);
     if (sourceFile && change.status === "deleted") {
       args.gaps.push({
         code: "deleted_source_unresolved",
@@ -1289,7 +1295,7 @@ function scopeSort(scope: AppChangeFileScope): number {
 }
 
 function moduleStem(file: string): string {
-  return normalizePath(file).replace(/\.(?:c|m)?[jt]sx?$/, "");
+  return stripSourceFileExtension(normalizePath(file));
 }
 
 function resolvedModuleKey(file: string): string {
@@ -1333,10 +1339,6 @@ function highestPriorityScope(
   );
 }
 
-function isSourceFile(file: string): boolean {
-  return /\.(?:c|m)?[jt]sx?$/.test(file) && !file.endsWith(".d.ts");
-}
-
 function isDocumentationPath(file: string, roots: string[]): boolean {
   const normalized = normalizePath(file);
   const basename = path.posix.basename(normalized);