LTplus-AG
diff --git a/‎packages/sdk/src/externalised-siblings.test.ts‎
Lines changed: 60 additions & 0 deletions b/‎packages/sdk/src/externalised-siblings.test.ts‎
Lines changed: 60 additions & 0 deletions
diff --git a/‎packages/sdk/src/namespaces/ids.test.ts‎
Lines changed: 4 additions & 11 deletions b/‎packages/sdk/src/namespaces/ids.test.ts‎
Lines changed: 4 additions & 11 deletions
diff --git a/‎packages/sdk/src/namespaces/list.test.ts‎
Lines changed: 1 addition & 39 deletions b/‎packages/sdk/src/namespaces/list.test.ts‎
Lines changed: 1 addition & 39 deletions
diff --git a/‎packages/sdk/vitest.config.ts‎
Lines changed: 83 additions & 0 deletions b/‎packages/sdk/vitest.config.ts‎
Lines changed: 83 additions & 0 deletions
@@ -0,0 +1,60 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import { expect, it } from 'vitest';
+
+/**
+ * `vitest.config.ts` stops vite re-transforming sibling packages' built output,
+ * which is what kept this package's lazily-imported namespaces inside a 5000ms
+ * test budget (#2935).
+ *
+ * That protection is action-at-a-distance: it lives in the config, not in the
+ * files it protects, and if it ever stops taking effect the tests do not fail
+ * -- they silently go back to paying a ~2s transform inside a 5s budget, and
+ * the flake returns on somebody else's PR. Absence of the protection looks
+ * exactly like success, which is the whole reason it is asserted here.
+ *
+ * One concrete way it could silently stop: vitest checks `deps.inline` BEFORE
+ * `deps.external`, so a later inline rule added for an unrelated reason
+ * overrides the pattern with no error at all. Verified: adding
+ * `inline: [/packages\/[^/]+\/dist\//]` turns this test red. Note it has to be
+ * path-shaped to do so -- `inline: [/@ifc-lite/]` changes nothing, because
+ * inline matches resolved paths too, which is the same trap as `external`.
+ *
+ * Asserted on the shape of the module namespace rather than on a timing, which
+ * would be flaky by construction. Under today's vite, a natively imported ES
+ * module namespace is sealed and one built by the SSR transform is not; every
+ * other distinguishing bit is identical (`proto === null`,
+ * `Symbol.toStringTag === 'Module'` in both). That makes sealed-ness the best
+ * cheap discriminator available rather than a definition -- if vite ever seals
+ * its namespaces this goes green while inlining, so the per-package coverage
+ * below is the real belt.
+ *
+ * Every heavy sibling is checked, not a sample. An earlier version asserted
+ * only `@ifc-lite/lists`, which is the SMALLEST of the eight packages
+ * externalised here at 168K; the cost is `@ifc-lite/data` at 9.8M and
+ * `@ifc-lite/parser` at 5.5M. Inlining just those two -- precisely the "later
+ * inline rule added for an unrelated reason" named above -- left the guard
+ * green while suite transform went 120ms to 944ms. The safety net had a hole
+ * in the exact shape of the threat it documents.
+ */
+it.each([
+  '@ifc-lite/data',
+  '@ifc-lite/parser',
+  '@ifc-lite/lists',
+  '@ifc-lite/clash',
+  '@ifc-lite/ids',
+])('imports %s natively, not through vite (#2935)', async (specifier) => {
+  const namespace: Record<string, unknown> = await import(/* @vite-ignore */ specifier);
+  const someExport = Object.keys(namespace)[0];
+  expect(someExport, `${specifier} must export something to inspect`).toBeTruthy();
+
+  const descriptor = Object.getOwnPropertyDescriptor(namespace, someExport);
+  expect(
+    { configurable: descriptor?.configurable, extensible: Object.isExtensible(namespace) },
+    `${specifier} came through vite's transform: its namespace is configurable and ` +
+      'extensible, where a native ESM one is neither. server.deps.external in ' +
+      'vitest.config.ts stopped applying to it, and the cold-transform flake is back',
+  ).toEqual({ configurable: false, extensible: false });
+});
@@ -13,17 +13,10 @@ import type {
 
 const ids = new IDSNamespace();
 
-// `IDSNamespace` dynamically imports `@ifc-lite/ids` on first use (see
-// `loadIDS` in ids.ts) so that SDK consumers who never touch `bim.ids`
-// don't pay for it. That's the right tradeoff for real callers, who load
-// the module once and then reuse it — but it means whichever test in this
-// file happens to be the first to call `validate`/`parse`/etc. pays the
-// one-time cold-import cost inside its own timer. Under CI's parallel test
-// load that cost alone can approach the default 5s test timeout. Warm the
-// import here, during module collection (unbounded by any per-test or
-// per-hook timeout), so the locale test below only times the logic it
-// exists to check.
-await import('@ifc-lite/ids');
+// `@ifc-lite/ids` is imported lazily by `loadIDS`. It used to be warmed here
+// so the locale test below did not pay the cold import inside its own budget;
+// that cost was vite re-transforming built sibling output, and it is gone --
+// see `vitest.config.ts`.
 
 const sv = (value: string): IDSSimpleValue => ({ type: 'simpleValue', value });
 
 
@@ -19,47 +19,9 @@
  * of undefined (reading 'length')` instead of running unfiltered.
  */
 
-import { beforeAll, describe, expect, it } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import { ListNamespace, type ListDefinition } from './list.js';
 
-/**
- * `ListNamespace.execute()` dynamically imports `@ifc-lite/lists` and
- * `@ifc-lite/data` on first use (`loadLists` in `list.ts`) so SDK consumers
- * who never touch `bim.list` don't pay for them. Right tradeoff for real
- * callers -- but it means whichever test here runs first pays the one-time
- * cold-import cost inside its own timer: measured at 2002ms cold and 481ms on
- * a warm repo, against 2-3ms once the modules are resolved.
- *
- * Under CI's parallel load that alone crosses the 5000ms default. This file
- * failed on FIVE unrelated PRs at once -- #2822, #2905, #2907, #2923, #2930 --
- * every one between 5005ms and 5056ms, while passing locally on the same
- * commit. Warming here moves the cost outside every `it()`'s budget, so each
- * test times only its own logic and keeps the tight default: a genuine hang
- * still fails in 5s rather than 30s.
- *
- * Same root cause and directory as `ids.test.ts` (3a00b5e64, which reported
- * 5021-5038ms), and the same shape as `packages/export/src/parquet-geometry.test.ts`
- * (#2248). `bcf.ts`, `drawing.ts` and `sandbox.ts` share the lazy-import idiom
- * and have not fired yet.
- *
- * Warmed rather than mocked: these tests exist to prove the real bridge to the
- * real library produces real values, and a mocked `executeList` would pass
- * with the very column-mapping bug they were written to catch (#2841).
- *
- * Known limitation, and the alternative was tried rather than assumed: this
- * names `execute()`'s imports instead of driving `execute()` itself, so a
- * third dependency added there would silently stop being covered. Driving the
- * real method would stay correct by construction, but every module-scope
- * `await` form breaks function hoisting in this file under vite's transform
- * (`makeProviderWithPsets` hits `ReferenceError: makeProvider is not
- * defined`), which is why the warm-up sits in `beforeAll`. If `execute()`
- * gains an import, add it here.
- */
-beforeAll(async () => {
-  await import('@ifc-lite/lists');
-  await import('@ifc-lite/data');
-}, 30_000);
-
 interface Provider {
   getEntitiesByType: (type: number) => number[];
   getAllEntityIds?: () => number[];
 
@@ -0,0 +1,83 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import { fileURLToPath } from 'node:url';
+import { defineConfig } from 'vitest/config';
+
+// Normalised to forward slashes: on win32 `fileURLToPath` yields `C:\repo\`,
+// while the pattern tail and the ids vitest tests against both use `/`, so the
+// regex would never match and externalisation would silently vanish.
+const repoRoot = fileURLToPath(new URL('../../', import.meta.url)).replaceAll('\\', '/');
+
+/**
+ * Sibling workspace packages, matched by their BUILT output.
+ *
+ * Anchored at the repo root rather than left as a floating substring: vitest
+ * tests this against a resolved absolute path, so an unanchored
+ * `packages/<x>/dist/` would also match a checkout that happens to live
+ * beneath some other `packages/<x>/dist/` directory -- and then it matches
+ * this package's own `src/*.ts` too, which Node cannot execute.
+ *
+ * `pkg` as well as `dist` is UNTESTED insurance, stated plainly: instrumenting
+ * the pattern over the full suite shows eight ids submitted, every one of them
+ * a `packages/<name>/dist/index.js`, and none under `pkg`. It is here because
+ * `@ifc-lite/wasm` builds to
+ * `packages/wasm/pkg/ifc-lite.js` (turbo's build outputs are
+ * `["dist/**", "pkg/**"]`). It is reachable from here through
+ * `@ifc-lite/clash/wasm`, and it is a large generated bundle -- exactly the
+ * thing that must not be re-transformed inside a lazy import's budget.
+ */
+const BUILT_SIBLING = new RegExp(
+  `^${repoRoot.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}packages/[^/]+/(dist|pkg)/`,
+);
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    // Load sibling workspace packages as the built JS they already are,
+    // instead of re-transforming them.
+    //
+    // pnpm links `@ifc-lite/*` as symlinks, so the specifier resolves to
+    // `packages/<name>/dist/index.js` -- a real path inside the project root.
+    // Vite therefore treats that built file as SOURCE and runs it through its
+    // SSR transform on every run. That transform, not module loading, is the
+    // cost: Node imports those same files in 12-40ms.
+    //
+    // It surfaced as a timeout rather than as slowness because the namespaces
+    // load their implementations with a dynamic `import()` on first use, so the
+    // whole transform landed inside the 5000ms budget of whichever test touched
+    // one first. Measured at 2002ms, it crossed the limit under CI load and took
+    // `main` red on 19 of 20 runs (#2935), after being patched one test file at
+    // a time three times before that (3a00b5e64, #2248).
+    //
+    // Full sdk suite, `--maxWorkers=2`, 3 reps, 173/173 green in every column:
+    //
+    //   before                       1.60s   (transform 1.38s)
+    //   warming the imports instead  2.28s   (transform 3.41s, setup 2.50s)
+    //   this                         0.61s   (transform 129ms)
+    //
+    // The two tests that flaked go to 29ms and 38ms with nothing warmed.
+    //
+    // Resolution is unchanged -- the import already resolved to `dist`; only the
+    // transform is removed, and every sibling `exports` map in this closure is a
+    // plain `{types, import, default}` with no condition that would pick a
+    // different file. It does mean the siblings must be BUILT: `turbo.json` gives
+    // `test` a `dependsOn: ["build"]`, and `build` in turn `["^build"]`, so turbo
+    // covers it transitively. Running `vitest` package-locally does not, but that
+    // was already true -- the import resolved to `dist` before this too.
+    //
+    // ONE REAL BEHAVIOUR CHANGE: externalised modules are native ESM, so their
+    // namespace objects are non-configurable and `vi.spyOn(await
+    // import('@ifc-lite/...'), 'someExport')` now throws "Module namespace is not
+    // configurable". `vi.mock` is unaffected and still wins over externalisation,
+    // for both static and dynamic imports. Nothing in the suite spies that way
+    // today; if you need to, use `vi.mock` with a factory.
+    //
+    // Written as a path pattern on purpose: `external: [/@ifc-lite\//]` does NOT
+    // work, because `external` matches resolved paths rather than specifiers, and
+    // pnpm realpaths the symlink so the id contains neither the specifier nor
+    // `/node_modules/`.
+    server: { deps: { external: [BUILT_SIBLING] } },
+  },
+});