As I feared, we have the build wrong

Author: NullVoxPopuli

packages/@glimmer-workspace/integration-node-tests/package.json

@@ -15,6 +15,7 @@
   },
   "dependencies": {
     "@glimmer/syntax": "workspace:*",
+    "execa": "^9.5.2",
     "prettier": "^3.4.2"
   },
   "devDependencies": {

packages/@glimmer-workspace/integration-node-tests/tests/prettier.test.ts

@@ -1,7 +1,12 @@
 import { describe, it, expect } from 'vitest';
 import * as prettier from 'prettier';
 import { createRequire } from 'node:module';
+import os from 'node:os';
+import { join } from 'node:path';
+import { $ } from 'execa';
+import { readFile, mkdtemp, writeFile } from 'node:fs/promises';
 
+const monorepoRoot = join(import.meta.dirname, '../../../../');
 const require = createRequire(import.meta.url);
 
 /**
@@ -15,7 +20,7 @@ describe('Prettier', () => {
   it(`SANITY: we've symlinked to the in-repo copy of @glimmer/syntax`, async () => {
     let workspacePath = require.resolve('@glimmer/syntax');
     let prettierPath = require.resolve('prettier');
-    let prettierGlimmer = require.resolve('@glimmer/syntax', {paths: [prettierPath]});
+    let prettierGlimmer = require.resolve('@glimmer/syntax', { paths: [prettierPath] });
 
     expect(prettierGlimmer).toBe(workspacePath);
   });
@@ -34,4 +39,108 @@ describe('Prettier', () => {
       </div>"
     `);
   });
+
+  /**
+   * This is important because we don't test the code we ship to npm
+   * (the code we ship to npm goes through a build process, and we opted
+   *  to not do that for in-repo dev ergonomics)
+   *
+   *  Process:
+   *  1. build @glimmer/syntax (and dependencies)
+   *  2. creat a tmp folder
+   *  3. create a project in that tmp folder
+   *  4. pack and add the tarballs to the project
+   *  6. See if a basic import and call to pre-process works
+   */
+  it('Uses the real build, and not our monorepo infra', async () => {
+    /**
+     * pnpm packs tgz's with the name format ${hyphenated-package-name}-${version}.tgz
+     */
+    async function versionOf(name) {
+      let manifestPath = join(monorepoRoot, 'packages', name, 'package.json');
+      let manifestString = await readFile(manifestPath);
+      return JSON.parse(manifestString.toString()).version;
+    }
+
+    let tarballs = {
+      syntax: `glimmer-syntax-${await versionOf('@glimmer/syntax')}`,
+      util: `glimmer-util-${await versionOf('@glimmer/util')}`,
+      wireFormat: `glimmer-wire-format-${await versionOf('@glimmer/wire-format')}`,
+    };
+
+    let file = `console.log((await import('@glimmer/syntax')).preprocess('<h1></h1>'));`;
+    let manifest = JSON.stringify({
+      name: 'real-test',
+      type: 'module',
+      private: true,
+      devDependencies: {
+        '@glimmer/syntax': `file://./${tarballs.syntax}`,
+        '@glimmer/util': `file://./${tarballs.util}`,
+        '@glimmer/wire-format': `file://./${tarballs.wireFormat}`,
+      },
+      pnpm: {
+        overrides: {
+          '@glimmer/syntax': `file://./${tarballs.syntax}.tgz`,
+          '@glimmer/util': `file://./${tarballs.util}.tgz`,
+          '@glimmer/wire-format': `file://./${tarballs.wireFormat}.tgz`,
+        },
+      },
+    });
+
+    async function newTmpDir() {
+      const tmpDir = await mkdtemp(
+        join(os.tmpdir(), `glimmer-node-integration-testing-${Date.now()}-`)
+      );
+
+      return tmpDir;
+    }
+
+    function inDir(dir: string, cmd: string) {
+      return $({ cwd: dir, preferLocal: true, shell: true })(cmd);
+    }
+    function inRoot(cmd: string) {
+      return inDir(monorepoRoot, cmd);
+    }
+
+    function inTmp(cmd: string) {
+      return inDir(tmp, cmd);
+    }
+
+    //////////
+    // 1 build
+    //   When turbo is set up with "dependsOn": "["^prepack"], we see these packages
+    //   - @glimmer/syntax
+    //   - @glimmer/util
+    //   - @glimmer/wire-format
+    //
+    //   So these 3 packages need to be packed and installed
+    await inRoot(`pnpm turbo --filter "@glimmer/syntax" prepack`);
+
+    //////////
+    // 2 create a space that doesn't mess up the repo
+    let tmp = await newTmpDir();
+
+    console.debug(`Project can be inspected at ${tmp}`);
+
+    //////////
+    // 3 create a project that represents real consumer usage
+    await writeFile(join(tmp, 'package.json'), manifest);
+    await writeFile(join(tmp, 'index.js'), file);
+
+    //////////
+    // 4 install the tarballs using stable names so we don't have to
+    //   dynamically build the package.json
+    let packToTemp = `pnpm pack --pack-destination ${tmp}`;
+    await inDir(join(monorepoRoot, 'packages/@glimmer/syntax'), packToTemp);
+    await inDir(join(monorepoRoot, 'packages/@glimmer/util'), packToTemp);
+    await inDir(join(monorepoRoot, 'packages/@glimmer/wire-format'), packToTemp);
+    await inTmp(`pnpm install`);
+
+    //////////
+    // 5 does it work?
+    let result = await inTmp(`node index.js`);
+    let stdout = result.stdout;
+
+    expect(stdout).toMatchInlineSnapshot();
+  });
 });