test(quick-260623-jwh): strict consumer-surface vue-tsc gate (Layer 2)

- strict tsconfig (strict:true + noImplicitAny:true) — full typed-consumer rigor the relaxed leaf tsconfig hides
- Consumer.vue imports sampled leaf public API by package name (data-table mandatory + listbox + sortable-list) via `.` exports → compiled dist .d.ts; typeof-position assignments force full type resolution
- harness mirrors VUE-TSC shape: mkdtemp + symlink node_modules + execFileSync vue-tsc --noEmit; fails loud if sampled dist absent
- add @tanstack/table-core, @tanstack/virtual-core, sortablejs/@types + leaf workspace devDeps; regenerate pnpm-lock.yaml (CI --frozen-lockfile)
- GREEN against compiled dist; deliberately-wrong typed import correctly fails

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011JE6gykywo57CcqUJZTsB9

Author: serpentblade

pnpm-lock.yaml

@@ -0,0 +1,84 @@
+<!--
+  Consumer.vue — Layer 2 strict consumer-surface stub (quick task 260623-jwh).
+
+  A real Vue consumer that imports the PUBLIC API of the sampled @rozie-ui Vue
+  leaves BY PACKAGE NAME (resolved through each package's `.` exports map → the
+  compiled dist/index.d.ts). Each import is used in a typed position so vue-tsc
+  actually checks the imported component types instead of tree-shaking them.
+
+  - data-table (MANDATORY): the heaviest leaf; its public surface references
+    @tanstack/table-core peer types. If its dist .d.ts is type-broken under a
+    strict consumer build, this stub fails vue-tsc (the 49-error regression class).
+  - listbox: a pure-Rozie (no-engine) leaf.
+  - sortable-list: an engine-wrapper leaf (sortablejs peer).
+
+  This SFC is dropped into a tmpdir alongside the strict tsconfig and typechecked
+  with `vue-tsc --noEmit` by vue-consumer-surface.test.ts.
+-->
+<script setup lang="ts">
+import {
+  DataTable,
+  Column,
+  EditorText,
+  EditorNumber,
+  EditorSelect,
+  EditorCheckbox,
+  EditorDate,
+  FilterText,
+  FilterNumberRange,
+  FilterSelect,
+  GroupBar,
+  DetailPanel,
+} from '@rozie-ui/data-table-vue';
+import { Listbox } from '@rozie-ui/listbox-vue';
+import { SortableList } from '@rozie-ui/sortable-list-vue';
+
+// Use each import in a typed position so vue-tsc checks the component types
+// rather than eliding the import. `typeof Import` resolves the component's
+// declared type from its dist .d.ts; an `any`-typed or type-broken export would
+// surface here under noImplicitAny:true.
+const dataTable: typeof DataTable = DataTable;
+const column: typeof Column = Column;
+const editorText: typeof EditorText = EditorText;
+const editorNumber: typeof EditorNumber = EditorNumber;
+const editorSelect: typeof EditorSelect = EditorSelect;
+const editorCheckbox: typeof EditorCheckbox = EditorCheckbox;
+const editorDate: typeof EditorDate = EditorDate;
+const filterText: typeof FilterText = FilterText;
+const filterNumberRange: typeof FilterNumberRange = FilterNumberRange;
+const filterSelect: typeof FilterSelect = FilterSelect;
+const groupBar: typeof GroupBar = GroupBar;
+const detailPanel: typeof DetailPanel = DetailPanel;
+const listbox: typeof Listbox = Listbox;
+const sortableList: typeof SortableList = SortableList;
+
+// Reference the bindings so they are not reported as unused.
+void [
+  dataTable,
+  column,
+  editorText,
+  editorNumber,
+  editorSelect,
+  editorCheckbox,
+  editorDate,
+  filterText,
+  filterNumberRange,
+  filterSelect,
+  groupBar,
+  detailPanel,
+  listbox,
+  sortableList,
+];
+</script>
+
+<template>
+  <!--
+    No render usage here: rendering a component forces every required prop (e.g.
+    DataTable's `data`), which is per-leaf and fragile. The `typeof Import`
+    typed-position assignments in <script setup> already force vue-tsc to fully
+    resolve + typecheck each imported component's type (props interface included)
+    from its dist .d.ts — which is exactly the leaf-surface rigor this gate exists
+    to enforce. An empty template keeps the SFC valid without inventing prop data.
+  -->
+  <div />
+</template>

tests/vue-typecheck/consumer-stub/Consumer.vue

@@ -12,6 +12,13 @@
     "@rozie/target-vue": "workspace:*"
   },
   "devDependencies": {
+    "@rozie-ui/data-table-vue": "workspace:*",
+    "@rozie-ui/listbox-vue": "workspace:*",
+    "@rozie-ui/sortable-list-vue": "workspace:*",
+    "@tanstack/table-core": "^8.21",
+    "@tanstack/virtual-core": "^3",
+    "@types/sortablejs": "^1.15",
+    "sortablejs": "^1.15",
     "typescript": "~5.6.0",
     "vitest": "^4",
     "vue": "^3.5.33",

tests/vue-typecheck/package.json

@@ -0,0 +1,21 @@
+{
+  "//": "STRICT consumer tsconfig (quick task 260623-jwh, Layer 2). Unlike the relaxed",
+  "//noImplicitAny": "tsconfig.json (noImplicitAny:false), this sets noImplicitAny:true to apply the",
+  "//rigor": "full typed-consumer rigor the leaf's relaxed tsconfig hides. A type-broken leaf",
+  "//catches": "dist .d.ts (the 49-error regression class) fails vue-tsc under this config.",
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "preserve",
+    "strict": true,
+    "noImplicitAny": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "lib": ["ES2022", "DOM"],
+    "types": ["vue"]
+  },
+  "include": ["**/*.vue", "**/*.ts"]
+}

tests/vue-typecheck/tsconfig.consumer.strict.json

@@ -0,0 +1,88 @@
+/**
+ * VUE-CONSUMER-SURFACE — Layer 2 strict consumer-surface gate (quick task 260623-jwh).
+ *
+ * Automates the verdaccio dogfood: proves a STRICT (strict:true + noImplicitAny:true)
+ * typed Vue consumer of the COMPILED leaf dist stays vue-tsc clean. This catches the
+ * "source-only Vue leaf breaks consumer vue-tsc with 49 errors" class for FUTURE leaves
+ * (threat T-jwh-02).
+ *
+ * Mirrors the existing VUE-TSC harness shape: mkdtempSync tmpdir, copy in the strict
+ * tsconfig (as tsconfig.json) + the Consumer.vue stub, symlink this package's
+ * node_modules (so the workspace-symlinked @rozie-ui leaf packages + vue + peer types
+ * resolve), then run `node_modules/.bin/vue-tsc --noEmit -p tsconfig.json` and throw
+ * with the captured stdout/stderr on non-zero.
+ *
+ * The consumer stub imports the sampled leaves BY PACKAGE NAME, so resolution goes
+ * through each package's `.` exports map → the compiled dist/index.d.ts. The sampled
+ * leaves MUST be built first (their dist .d.ts must exist):
+ *   pnpm turbo run build --filter "@rozie-ui/*-vue"
+ * In CI this is covered by the preceding `pnpm turbo run build` step (Layer 3).
+ *
+ * Sample = data-table (MANDATORY) + listbox (pure-Rozie) + sortable-list (engine-wrapper).
+ */
+import { describe, it, expect } from 'vitest';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, rmSync, copyFileSync, symlinkSync, mkdirSync, existsSync } from 'node:fs';
+import { join, resolve, dirname } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(HERE, '../..');
+
+// Sampled leaves whose compiled dist .d.ts the consumer stub imports. The test
+// asserts each is built before running so a missing-dist run fails loud (not a
+// false green) rather than silently resolving nothing.
+const SAMPLED_DIST = [
+  'packages/ui/data-table/packages/vue/dist/index.d.ts',
+  'packages/ui/listbox/packages/vue/dist/index.d.ts',
+  'packages/ui/sortable-list/packages/vue/dist/index.d.ts',
+];
+
+describe('VUE-CONSUMER-SURFACE — strict typed consumer of compiled leaf dist is vue-tsc clean (Layer 2)', () => {
+  it('Consumer.vue importing sampled @rozie-ui leaf dist typechecks clean under strict tsconfig', () => {
+    // Fail loud if the sampled leaves were not built — the consumer resolves their
+    // compiled dist .d.ts, so a missing dist is a setup error, not a pass.
+    const missing = SAMPLED_DIST.filter((p) => !existsSync(resolve(ROOT, p)));
+    if (missing.length > 0) {
+      throw new Error(
+        'Sampled Vue leaf dist .d.ts missing — build them first ' +
+          '(`pnpm turbo run build --filter "@rozie-ui/*-vue"`):\n  ' +
+          missing.join('\n  '),
+      );
+    }
+
+    const tmpDir = mkdtempSync(join(tmpdir(), 'rozie-vue-consumer-'));
+    try {
+      // Strict consumer tsconfig (strict + noImplicitAny) → tsconfig.json in tmp.
+      copyFileSync(join(HERE, 'tsconfig.consumer.strict.json'), join(tmpDir, 'tsconfig.json'));
+      // The typed consumer stub.
+      mkdirSync(join(tmpDir, 'consumer-stub'), { recursive: true });
+      copyFileSync(
+        join(HERE, 'consumer-stub', 'Consumer.vue'),
+        join(tmpDir, 'consumer-stub', 'Consumer.vue'),
+      );
+      // Symlink this package's node_modules so the workspace-symlinked @rozie-ui
+      // leaves + vue + @tanstack peer types resolve through their real exports maps.
+      symlinkSync(join(HERE, 'node_modules'), join(tmpDir, 'node_modules'), 'dir');
+
+      const vueTscBin = resolve(HERE, 'node_modules/.bin/vue-tsc');
+      try {
+        execFileSync(vueTscBin, ['--noEmit', '-p', 'tsconfig.json'], {
+          cwd: tmpDir,
+          stdio: 'pipe',
+        });
+      } catch (err) {
+        const stdout = (err as { stdout?: Buffer }).stdout?.toString() ?? '';
+        const stderr = (err as { stderr?: Buffer }).stderr?.toString() ?? '';
+        throw new Error(
+          'vue-tsc --noEmit exited non-zero for the strict consumer surface:\n' + stdout + '\n' + stderr,
+        );
+      }
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+
+    expect(true).toBe(true);
+  });
+});