@smoothbricks/lmao 0.3.0 → 0.3.2

package/dist/ts/wasm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm.d.ts","sourceRoot":"","sources":["../../src/wasm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,KAAK,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AACtG,OAAO,EACL,mBAAmB,EACnB,uBAAuB,EACvB,qBAAqB,EACrB,wBAAwB,EACxB,uBAAuB,EACvB,KAAK,aAAa,EAClB,KAAK,oBAAoB,GAC1B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,wBAAwB,EACxB,KAAK,sBAAsB,GAC5B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,mBAAmB,EACnB,0BAA0B,EAC1B,aAAa,GACd,MAAM,6BAA6B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smoothbricks/lmao",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "type": "module",
   "sideEffects": [
     "./dist/vocabulary/register/v1.js",
@@ -8,135 +8,135 @@
     "./dist/lib/span-buffer/aot/v1.js",
     "./src/lib/span-buffer/aot/v1.ts"
   ],
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/ts/index.js",
+  "module": "./dist/ts/index.js",
+  "types": "./dist/ts/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "types": "./dist/index.d.ts",
+      "types": "./dist/ts/index.d.ts",
       "development": "./src/index.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "import": "./dist/ts/index.js",
+      "default": "./dist/ts/index.js"
     },
     "./span-buffer/aot/v1": {
-      "types": "./dist/lib/span-buffer/aot/v1.d.ts",
+      "types": "./dist/ts/lib/span-buffer/aot/v1.d.ts",
       "development": "./src/lib/span-buffer/aot/v1.ts",
-      "import": "./dist/lib/span-buffer/aot/v1.js",
-      "default": "./dist/lib/span-buffer/aot/v1.js"
+      "import": "./dist/ts/lib/span-buffer/aot/v1.js",
+      "default": "./dist/ts/lib/span-buffer/aot/v1.js"
     },
     "./vocabulary/register/v1": {
-      "types": "./dist/vocabulary/register/v1.d.ts",
+      "types": "./dist/ts/vocabulary/register/v1.d.ts",
       "development": "./src/vocabulary/register/v1.ts",
-      "import": "./dist/vocabulary/register/v1.js",
-      "default": "./dist/vocabulary/register/v1.js"
+      "import": "./dist/ts/vocabulary/register/v1.js",
+      "default": "./dist/ts/vocabulary/register/v1.js"
     },
     "./node": {
-      "types": "./dist/node.d.ts",
+      "types": "./dist/ts/node.d.ts",
       "development": "./src/node.ts",
-      "import": "./dist/node.js",
-      "default": "./dist/node.js"
+      "import": "./dist/ts/node.js",
+      "default": "./dist/ts/node.js"
     },
     "./es": {
-      "types": "./dist/es.d.ts",
+      "types": "./dist/ts/es.d.ts",
       "development": "./src/es.ts",
-      "import": "./dist/es.js",
-      "default": "./dist/es.js"
+      "import": "./dist/ts/es.js",
+      "default": "./dist/ts/es.js"
     },
     "./wasm": {
-      "types": "./dist/wasm.d.ts",
+      "types": "./dist/ts/wasm.d.ts",
       "development": "./src/wasm.ts",
-      "import": "./dist/wasm.js",
-      "default": "./dist/wasm.js"
+      "import": "./dist/ts/wasm.js",
+      "default": "./dist/ts/wasm.js"
     },
     "./cloudflare": {
-      "types": "./dist/cloudflare.d.ts",
+      "types": "./dist/ts/cloudflare.d.ts",
       "development": "./src/cloudflare.ts",
-      "import": "./dist/cloudflare.js",
-      "default": "./dist/cloudflare.js"
+      "import": "./dist/ts/cloudflare.js",
+      "default": "./dist/ts/cloudflare.js"
     },
     "./tracers": {
-      "types": "./dist/lib/tracers/index.d.ts",
+      "types": "./dist/ts/lib/tracers/index.d.ts",
       "development": "./src/lib/tracers/index.ts",
-      "import": "./dist/lib/tracers/index.js",
-      "default": "./dist/lib/tracers/index.js"
+      "import": "./dist/ts/lib/tracers/index.js",
+      "default": "./dist/ts/lib/tracers/index.js"
     },
     "./errors": {
-      "types": "./dist/lib/errors/index.d.ts",
+      "types": "./dist/ts/lib/errors/index.d.ts",
       "development": "./src/lib/errors/index.ts",
-      "import": "./dist/lib/errors/index.js",
-      "default": "./dist/lib/errors/index.js"
+      "import": "./dist/ts/lib/errors/index.js",
+      "default": "./dist/ts/lib/errors/index.js"
     },
     "./errors/Blocked": {
-      "types": "./dist/lib/errors/Blocked.d.ts",
+      "types": "./dist/ts/lib/errors/Blocked.d.ts",
       "development": "./src/lib/errors/Blocked.ts",
-      "import": "./dist/lib/errors/Blocked.js",
-      "default": "./dist/lib/errors/Blocked.js"
+      "import": "./dist/ts/lib/errors/Blocked.js",
+      "default": "./dist/ts/lib/errors/Blocked.js"
     },
     "./errors/RetriesExhausted": {
-      "types": "./dist/lib/errors/RetriesExhausted.d.ts",
+      "types": "./dist/ts/lib/errors/RetriesExhausted.d.ts",
       "development": "./src/lib/errors/RetriesExhausted.ts",
-      "import": "./dist/lib/errors/RetriesExhausted.js",
-      "default": "./dist/lib/errors/RetriesExhausted.js"
+      "import": "./dist/ts/lib/errors/RetriesExhausted.js",
+      "default": "./dist/ts/lib/errors/RetriesExhausted.js"
     },
     "./errors/CodeError": {
-      "types": "./dist/lib/errors/CodeError.d.ts",
+      "types": "./dist/ts/lib/errors/CodeError.d.ts",
       "development": "./src/lib/errors/CodeError.ts",
-      "import": "./dist/lib/errors/CodeError.js",
-      "default": "./dist/lib/errors/CodeError.js"
+      "import": "./dist/ts/lib/errors/CodeError.js",
+      "default": "./dist/ts/lib/errors/CodeError.js"
     },
     "./errors/retry-policy": {
-      "types": "./dist/lib/errors/retry-policy.d.ts",
+      "types": "./dist/ts/lib/errors/retry-policy.d.ts",
       "development": "./src/lib/errors/retry-policy.ts",
-      "import": "./dist/lib/errors/retry-policy.js",
-      "default": "./dist/lib/errors/retry-policy.js"
+      "import": "./dist/ts/lib/errors/retry-policy.js",
+      "default": "./dist/ts/lib/errors/retry-policy.js"
     },
     "./errors/Transient": {
-      "types": "./dist/lib/errors/Transient.d.ts",
+      "types": "./dist/ts/lib/errors/Transient.d.ts",
       "development": "./src/lib/errors/Transient.ts",
-      "import": "./dist/lib/errors/Transient.js",
-      "default": "./dist/lib/errors/Transient.js"
+      "import": "./dist/ts/lib/errors/Transient.js",
+      "default": "./dist/ts/lib/errors/Transient.js"
     },
     "./sqlite": {
-      "types": "./dist/lib/sqlite/index.d.ts",
+      "types": "./dist/ts/lib/sqlite/index.d.ts",
       "development": "./src/lib/sqlite/index.ts",
-      "import": "./dist/lib/sqlite/index.js",
-      "default": "./dist/lib/sqlite/index.js"
+      "import": "./dist/ts/lib/sqlite/index.js",
+      "default": "./dist/ts/lib/sqlite/index.js"
     },
     "./sqlite/node": {
-      "types": "./dist/lib/sqlite/sqlite-node.d.ts",
+      "types": "./dist/ts/lib/sqlite/sqlite-node.d.ts",
       "development": "./src/lib/sqlite/sqlite-node.ts",
-      "import": "./dist/lib/sqlite/sqlite-node.js",
-      "default": "./dist/lib/sqlite/sqlite-node.js"
+      "import": "./dist/ts/lib/sqlite/sqlite-node.js",
+      "default": "./dist/ts/lib/sqlite/sqlite-node.js"
     },
     "./testing": {
-      "types": "./dist/testing.d.ts",
+      "types": "./dist/ts/testing.d.ts",
       "development": "./src/testing.ts",
-      "import": "./dist/testing.js",
-      "default": "./dist/testing.js"
+      "import": "./dist/ts/testing.js",
+      "default": "./dist/ts/testing.js"
     },
     "./testing/bun": {
-      "types": "./dist/lib/testing/bun-harness.d.ts",
+      "types": "./dist/ts/lib/testing/bun-harness.d.ts",
       "bun": "./src/lib/testing/bun-harness.ts",
       "development": "./src/lib/testing/bun-harness.ts",
-      "import": "./dist/lib/testing/bun-harness.js",
-      "default": "./dist/lib/testing/bun-harness.js"
+      "import": "./dist/ts/lib/testing/bun-harness.js",
+      "default": "./dist/ts/lib/testing/bun-harness.js"
     },
     "./testing/vitest": {
-      "types": "./dist/lib/testing/vitest-harness.d.ts",
+      "types": "./dist/ts/lib/testing/vitest-harness.d.ts",
       "development": "./src/lib/testing/vitest-harness.ts",
-      "import": "./dist/lib/testing/vitest-harness.js",
-      "default": "./dist/lib/testing/vitest-harness.js"
+      "import": "./dist/ts/lib/testing/vitest-harness.js",
+      "default": "./dist/ts/lib/testing/vitest-harness.js"
     },
     "./bun/preload": {
       "bun": "./src/bun/preload.ts",
       "development": "./src/bun/preload.ts",
-      "default": "./dist/bun/preload.js"
+      "default": "./dist/ts/bun/preload.js"
     },
     "./bun/trace-preload": {
       "bun": "./src/bun/trace-preload.ts",
       "development": "./src/bun/trace-preload.ts",
-      "default": "./dist/bun/trace-preload.js"
+      "default": "./dist/ts/bun/trace-preload.js"
     }
   },
   "files": [
@@ -147,11 +147,11 @@
   "dependencies": {
     "@msgpack/msgpack": "^3.1.3",
     "@neophi/sieve-cache": "^1.5.0",
-    "@smoothbricks/arrow-builder": "0.1.5",
-    "@smoothbricks/validation": "0.1.4",
+    "@smoothbricks/arrow-builder": "0.1.6",
+    "@smoothbricks/validation": "0.1.5",
     "@uwdata/flechette": "^2.3.0",
     "tslib": "^2.8.1",
-    "typia": "13.1.19"
+    "typia": "13.2.0"
   },
   "scripts": {
     "bench": "bun run benchmarks/*.bench.ts",

package/src/bun/trace-preload.ts

@@ -2,13 +2,25 @@
  * Bun test tracing preload.
  *
  * Registers LMAO SQLite-backed test tracing after the Typia preload has already
- * been registered in bunfig.
+ * been registered in bunfig. Wiring-only: consumer resolution lives in
+ * `../lib/testing/consumer-package.js`.
  */
 
-import { join } from 'node:path';
 import { autoSetupBunTestTracing } from '../lib/testing/bun-harness.js';
+import { resolveConsumerTarget } from '../lib/testing/consumer-package.js';
 
-// WHY: Find the monorepo packages dir relative to this file's location.
-// This file lives at packages/lmao/src/bun/trace-preload.ts (4 levels up to monorepo root).
-const monorepoRoot = join(import.meta.dir, '..', '..', '..', '..');
-await autoSetupBunTestTracing({ packagesDir: join(monorepoRoot, 'packages') });
+const target = resolveConsumerTarget(process.cwd());
+if (target.kind === 'package') {
+  await autoSetupBunTestTracing({ packageRoot: target.packageRoot });
+} else if (target.kind === 'workspace-root') {
+  await autoSetupBunTestTracing({ workspaceRoot: target.workspaceRoot, packageRoots: target.packageRoots });
+} else {
+  // WHY loud: this preload is only ever loaded on purpose (bunfig `preload`),
+  // so failing to install tracing must never be a silent no-op — that is how
+  // stale .trace-results.db databases go unnoticed for months.
+  console.error(
+    `[lmao] trace-preload: no package.json found above ${process.cwd()} ` +
+      `(searched: ${target.searched.join(', ')}). Test tracing is DISABLED for this run — ` +
+      'run bun test from inside a package.',
+  );
+}

package/src/lib/__tests__/package-exports.test.ts

@@ -31,6 +31,14 @@ function expectCoreConditions(entry: unknown): asserts entry is ExportConditions
   expect(requireStringProperty(record, 'default')).toBeString();
 }
 
+type PublishedWasmModule = {
+  createWasmAllocator(): Promise<unknown>;
+};
+
+function isPublishedWasmModule(value: unknown): value is PublishedWasmModule {
+  return isRecord(value) && typeof value.createWasmAllocator === 'function';
+}
+
 async function readPackageExports(packageUrl: URL): Promise<Record<string, unknown>> {
   const pkg = await Bun.file(packageUrl).json();
   const pkgRecord = requireRecord(pkg, 'package.json');
@@ -48,6 +56,19 @@ describe('package export conditions', () => {
     expect(exports['./package.json']).toBe('./package.json');
   });
 
+  it('loads the declared published wasm module and allocator artifact', async () => {
+    const packageUrl = new URL('../../../package.json', import.meta.url);
+    const exports = await readPackageExports(packageUrl);
+    const wasmConditions = requireRecord(exports['./wasm'], 'wasm export conditions');
+    const importTarget = requireStringProperty(wasmConditions, 'import');
+    const wasmModule: unknown = await import(new URL(importTarget, packageUrl).href);
+    if (!isPublishedWasmModule(wasmModule)) throw new Error('Published wasm module lacks createWasmAllocator');
+
+    const allocator = requireRecord(await wasmModule.createWasmAllocator(), 'published wasm allocator');
+
+    expect(allocator.capacity).toBe(64);
+  });
+
   it('arrow-builder package root export has expected conditions', async () => {
     const exports = await readPackageExports(new URL('../../../../arrow-builder/package.json', import.meta.url));
 

package/src/lib/testing/__tests__/consumer-package.test.ts

@@ -0,0 +1,106 @@
+/**
+ * Tests for consumer-package resolution.
+ *
+ * The resolver must identify "the package whose tests are running" by standard
+ * resolution semantics — nearest package.json above cwd — identically in every
+ * layout: a monorepo checkout, a consumer of the Bun isolated store, or plain
+ * node_modules. The regression this guards: resolution anchored on the
+ * library's own file location left consumer repos' .trace-results.db silently
+ * stale.
+ */
+
+import { afterEach, describe, expect, it } from 'bun:test';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { resolveConsumerTarget } from '../consumer-package.js';
+
+const roots: string[] = [];
+
+function makeTree(dirs: readonly string[], files: Readonly<Record<string, string>>): string {
+  const root = mkdtempSync(join(tmpdir(), 'lmao-consumer-'));
+  roots.push(root);
+  for (const dir of dirs) mkdirSync(join(root, dir), { recursive: true });
+  for (const [path, content] of Object.entries(files)) writeFileSync(join(root, path), content);
+  return root;
+}
+
+afterEach(() => {
+  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+describe('resolveConsumerTarget', () => {
+  it('resolves the nearest package.json as the consumer package root', () => {
+    const root = makeTree(['repo/packages/some-app/src/deep'], {
+      'repo/package.json': '{"workspaces":["packages/*"]}',
+      'repo/packages/some-app/package.json': '{}',
+    });
+    const target = resolveConsumerTarget(join(root, 'repo', 'packages', 'some-app', 'src', 'deep'));
+    expect(target.kind).toBe('package');
+    if (target.kind === 'package') expect(target.packageRoot).toBe(join(root, 'repo', 'packages', 'some-app'));
+  });
+
+  it('resolves in a foreign consumer workspace regardless of where the library is installed', () => {
+    // Consumer repo whose lmao copy lives under the Bun isolated store — the
+    // resolver must anchor on cwd, never on any path related to the store.
+    const root = makeTree(
+      [
+        'repo/packages/consumer-pkg',
+        'repo/node_modules/.bun/@smoothbricks+lmao@0.0.0+cafebabe/node_modules/@smoothbricks/lmao',
+      ],
+      {
+        'repo/package.json': '{"workspaces":["packages/*"]}',
+        'repo/packages/consumer-pkg/package.json': '{}',
+      },
+    );
+    const target = resolveConsumerTarget(join(root, 'repo', 'packages', 'consumer-pkg'));
+    expect(target.kind).toBe('package');
+    if (target.kind === 'package') expect(target.packageRoot).toBe(join(root, 'repo', 'packages', 'consumer-pkg'));
+  });
+
+  it('treats a nearest package.json with workspaces as a workspace-root run and expands members', () => {
+    const root = makeTree(['repo/packages/a', 'repo/packages/b', 'repo/packages/not-a-pkg', 'repo/tools/standalone'], {
+      'repo/package.json': '{"workspaces":["packages/*","tools/standalone"]}',
+      'repo/packages/a/package.json': '{}',
+      'repo/packages/b/package.json': '{}',
+      'repo/tools/standalone/package.json': '{}',
+    });
+    const target = resolveConsumerTarget(join(root, 'repo'));
+    expect(target.kind).toBe('workspace-root');
+    if (target.kind === 'workspace-root') {
+      expect(target.workspaceRoot).toBe(join(root, 'repo'));
+      expect([...target.packageRoots].sort()).toEqual([
+        join(root, 'repo', 'packages', 'a'),
+        join(root, 'repo', 'packages', 'b'),
+        join(root, 'repo', 'tools', 'standalone'),
+      ]);
+    }
+  });
+
+  it('prefers a member package over the workspace root when cwd is inside the member', () => {
+    const root = makeTree(['repo/packages/member'], {
+      'repo/package.json': '{"workspaces":["packages/*"]}',
+      'repo/packages/member/package.json': '{}',
+    });
+    const target = resolveConsumerTarget(join(root, 'repo', 'packages', 'member'));
+    expect(target.kind).toBe('package');
+  });
+
+  it('classifies a workspace-root run from a non-member subdirectory', () => {
+    const root = makeTree(['repo/scripts', 'repo/packages/a'], {
+      'repo/package.json': '{"workspaces":["packages/*"]}',
+      'repo/packages/a/package.json': '{}',
+    });
+    const target = resolveConsumerTarget(join(root, 'repo', 'scripts'));
+    expect(target.kind).toBe('workspace-root');
+  });
+
+  it('degrades malformed package.json to a plain package root instead of crashing', () => {
+    const root = makeTree(['repo/pkg'], {
+      'repo/pkg/package.json': '{not json',
+    });
+    const target = resolveConsumerTarget(join(root, 'repo', 'pkg'));
+    expect(target.kind).toBe('package');
+    if (target.kind === 'package') expect(target.packageRoot).toBe(join(root, 'repo', 'pkg'));
+  });
+});

package/src/lib/testing/bun-harness.ts

@@ -972,19 +972,26 @@ export {
 // Auto-discovery preload
 // =============================================================================
 
-export type AutoSetupOptions = {
-  /** Absolute path to the packages directory to scan for test-suite-tracer.ts files. */
-  packagesDir: string;
-};
+export type AutoSetupTarget =
+  | {
+      /** Root of the single consumer package whose tests are running. */
+      readonly packageRoot: string;
+    }
+  | {
+      /** Workspace root for a cross-package run, with its member package roots. */
+      readonly workspaceRoot: string;
+      readonly packageRoots: readonly string[];
+    };
 
 /**
- * Auto-discover package test-suite-tracers and create the root tracer for the
- * current bun test run.
+ * Create the root tracer for the current bun test run from a resolved consumer
+ * target (see `resolveConsumerTarget` in `./consumer-package.js`).
  *
- * When Bun is running from inside `packages/<name>`, prefer that package's own
- * `src/test-suite-tracer.ts` and avoid importing unrelated packages. Repo-root
- * runs still fall back to the full scan so cross-package test runs keep the
- * merged-schema behavior.
+ * A package target imports that package's own `src/test-suite-tracer.ts` (if
+ * present) and writes `.trace-results.db` at the package root. A
+ * workspace-root target scans the member packages' tracer modules so
+ * cross-package runs keep the merged-schema behavior, writing the DB at the
+ * workspace root.
  *
  * Per-package `useTestSpan()` delegates to the global `useTestSpan()` from this
  * module which checks `_activeSuiteTracer` — set by the root preload via
@@ -992,22 +999,19 @@ export type AutoSetupOptions = {
  *
  * @example
  * ```ts
- * // test-trace-preload.ts (monorepo root)
- * import { autoSetupBunTestTracing } from './packages/lmao/src/lib/testing/bun-harness.js';
- * await autoSetupBunTestTracing({ packagesDir: './packages' });
+ * // bun trace preload
+ * const target = resolveConsumerTarget(process.cwd());
+ * if (target.kind === 'package') await autoSetupBunTestTracing({ packageRoot: target.packageRoot });
  * ```
  */
-export async function autoSetupBunTestTracing(options: AutoSetupOptions): Promise<boolean> {
-  const { join, relative, resolve, sep } = await import('node:path');
-  const { existsSync, readdirSync } = await import('node:fs');
+export async function autoSetupBunTestTracing(target: AutoSetupTarget): Promise<boolean> {
+  const { join } = await import('node:path');
+  const { existsSync } = await import('node:fs');
 
-  const packagesDir = resolve(options.packagesDir);
-  if (!existsSync(packagesDir)) return false;
-
-  const installSuite = (opContext: OpContextBinding, mergedSchema: Record<string, unknown>): boolean => {
+  const installSuite = (opContext: OpContextBinding, mergedSchema: Record<string, unknown>, dbDir: string): boolean => {
     const hasCustomSchema = Object.keys(mergedSchema).length > 0;
     const suite = makeBunTestSuiteTracer(opContext, {
-      sqlite: { dbPath: '.trace-results.db' },
+      sqlite: { dbPath: join(dbDir, '.trace-results.db') },
       extraTestColumns: hasCustomSchema && isSchemaFieldsRecord(mergedSchema) ? mergedSchema : undefined,
     });
 
@@ -1015,34 +1019,25 @@ export async function autoSetupBunTestTracing(options: AutoSetupOptions): Promis
     return true;
   };
 
-  const cwd = resolve(process.cwd());
-  const relativeToPackagesDir = relative(packagesDir, cwd);
-  const isPackageLocalRun =
-    relativeToPackagesDir !== '' &&
-    !relativeToPackagesDir.startsWith('..') &&
-    !relativeToPackagesDir.startsWith(`.${sep}`);
-
-  if (isPackageLocalRun) {
-    const [packageName] = relativeToPackagesDir.split(sep);
-    const tracerPath = join(packagesDir, packageName, 'src', 'test-suite-tracer.ts');
+  if ('packageRoot' in target) {
+    const tracerPath = join(target.packageRoot, 'src', 'test-suite-tracer.ts');
 
     if (!existsSync(tracerPath)) {
-      return installSuite(defaultAutoSetupOpContext, {});
+      return installSuite(defaultAutoSetupOpContext, {}, target.packageRoot);
     }
 
     const mod = await import(tracerPath);
     const mergedSchema = isSchemaFieldsRecord(mod.extraTestColumns) ? mod.extraTestColumns : {};
     const opContext = isOpContextBindingLike(mod.opContext) ? mod.opContext : defaultAutoSetupOpContext;
 
-    return installSuite(opContext, mergedSchema);
+    return installSuite(opContext, mergedSchema, target.packageRoot);
   }
 
   const mergedSchema: Record<string, unknown> = {};
   let opContext: OpContextBinding | null = null;
 
-  for (const entry of readdirSync(packagesDir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const tracerPath = join(packagesDir, entry.name, 'src', 'test-suite-tracer.ts');
+  for (const packageRoot of target.packageRoots) {
+    const tracerPath = join(packageRoot, 'src', 'test-suite-tracer.ts');
     if (!existsSync(tracerPath)) continue;
 
     const mod = await import(tracerPath);
@@ -1058,5 +1053,5 @@ export async function autoSetupBunTestTracing(options: AutoSetupOptions): Promis
     }
   }
 
-  return installSuite(opContext ?? defaultAutoSetupOpContext, mergedSchema);
+  return installSuite(opContext ?? defaultAutoSetupOpContext, mergedSchema, target.workspaceRoot);
 }

package/src/lib/testing/consumer-package.ts

@@ -0,0 +1,93 @@
+/**
+ * Resolve the consumer package whose tests are running.
+ *
+ * WHY nearest-package.json, anchored on cwd: standard resolution semantics
+ * identify "the package whose tests are running" identically in every layout —
+ * a monorepo checkout, a consumer of the Bun isolated store
+ * (`node_modules/.bun/…`), or plain node_modules. This module ships inside an
+ * installed dependency, so nothing may ever be derived from its own file
+ * location; the test process cwd is the only truthful anchor.
+ */
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+export type ConsumerTarget =
+  | { readonly kind: 'package'; readonly packageRoot: string }
+  | { readonly kind: 'workspace-root'; readonly workspaceRoot: string; readonly packageRoots: readonly string[] }
+  | { readonly kind: 'not-found'; readonly searched: readonly string[] };
+
+/**
+ * WHY a hand-rolled structural probe instead of Typia: this runs on the
+ * preload bootstrap path, before the validation toolchain is guaranteed to be
+ * registered, and a malformed package.json must degrade to "plain package
+ * root", never to a crash that disables tracing.
+ */
+function readWorkspacePatterns(packageJsonPath: string): readonly string[] | null {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+    if (typeof parsed !== 'object' || parsed === null) return null;
+    const workspaces: unknown = Reflect.get(parsed, 'workspaces');
+    const patterns = Array.isArray(workspaces) ? workspaces : null;
+    if (!patterns) return null;
+    return patterns.filter((entry): entry is string => typeof entry === 'string');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Expand workspace member patterns to existing package roots. Supports the
+ * forms Bun workspaces support in practice: a literal directory and a single
+ * trailing `/*` glob.
+ */
+function expandWorkspaceMembers(workspaceRoot: string, patterns: readonly string[]): readonly string[] {
+  const roots: string[] = [];
+  for (const pattern of patterns) {
+    if (pattern.endsWith('/*')) {
+      const parent = join(workspaceRoot, pattern.slice(0, -2));
+      if (!existsSync(parent)) continue;
+      for (const entry of readdirSync(parent, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue;
+        const candidate = join(parent, entry.name);
+        if (existsSync(join(candidate, 'package.json'))) roots.push(candidate);
+      }
+    } else {
+      const candidate = join(workspaceRoot, pattern);
+      if (existsSync(join(candidate, 'package.json'))) roots.push(candidate);
+    }
+  }
+  return roots;
+}
+
+/**
+ * Walk up from `startDir` to the nearest directory holding a `package.json`.
+ * A nearest package.json that declares `workspaces` is a workspace-root run
+ * (cwd sits at or under the root but inside no member package — a member's own
+ * package.json would have been nearer); its members are expanded for the
+ * cross-package tracer scan.
+ */
+export function resolveConsumerTarget(startDir: string): ConsumerTarget {
+  const searched: string[] = [];
+  let directory = resolve(startDir);
+  while (true) {
+    const packageJsonPath = join(directory, 'package.json');
+    searched.push(packageJsonPath);
+    if (existsSync(packageJsonPath)) {
+      const workspacePatterns = readWorkspacePatterns(packageJsonPath);
+      if (workspacePatterns !== null) {
+        return {
+          kind: 'workspace-root',
+          workspaceRoot: directory,
+          packageRoots: expandWorkspaceMembers(directory, workspacePatterns),
+        };
+      }
+      return { kind: 'package', packageRoot: directory };
+    }
+    const parent = dirname(directory);
+    if (parent === directory) {
+      return { kind: 'not-found', searched };
+    }
+    directory = parent;
+  }
+}

package/src/lib/wasm/wasmAllocator.ts

@@ -429,10 +429,12 @@ async function loadWasmBytes(): Promise<ArrayBuffer> {
     const { fileURLToPath } = await import('node:url');
     const { dirname, join } = await import('node:path');
 
-    // __dirname equivalent for ESM
+    // Source imports live under src/; published modules live under dist/ts/.
     const currentFile = fileURLToPath(import.meta.url);
     const currentDir = dirname(currentFile);
-    const wasmPath = join(currentDir, '../../../dist', WASM_ARTIFACT_NAME);
+    const wasmPath = import.meta.url.includes('/dist/ts/')
+      ? join(currentDir, '../../../', WASM_ARTIFACT_NAME)
+      : join(currentDir, '../../../dist', WASM_ARTIFACT_NAME);
 
     const buffer = await readFile(wasmPath);
     // Create a proper ArrayBuffer from the Node.js Buffer
@@ -442,7 +444,10 @@ async function loadWasmBytes(): Promise<ArrayBuffer> {
   }
 
   // Browser: fetch from relative path
-  const response = await fetch(new URL(`../../../dist/${WASM_ARTIFACT_NAME}`, import.meta.url));
+  const wasmPath = import.meta.url.includes('/dist/ts/')
+    ? `../../../${WASM_ARTIFACT_NAME}`
+    : `../../../dist/${WASM_ARTIFACT_NAME}`;
+  const response = await fetch(new URL(wasmPath, import.meta.url));
   return response.arrayBuffer();
 }
 

package/dist/bun/preload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"preload.d.ts","sourceRoot":"","sources":["../../src/bun/preload.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,sCAAsC,CAAC"}