bootstrapper:

name: Bootstrapper Resolution

runs-on: ubuntu-latest

needs: [setup, build]

steps:

- name: Checkout

uses: actions/checkout@v4

- name: Setup pnpm

uses: pnpm/action-setup@v4

with:

version: ${{ env.PNPM_VERSION }}

- name: Setup Node.js

uses: actions/setup-node@v4

with:

node-version: ${{ env.NODE_VERSION }}

cache: 'pnpm'

- name: Restore node_modules

uses: actions/cache@v4

with:

path: |

key: node-modules-${{ runner.os }}-${{ hashFiles('pnpm-lock.yaml') }}

fail-on-cache-miss: true

- name: Restore build outputs

uses: actions/cache@v4

with:

path: |

key: build-${{ runner.os }}-${{ hashFiles('packages/*/src/**','examples/*/src/**','tsconfig*.json','pnpm-lock.yaml','packages/php-json-ast/composer.lock','packages/php-json-ast/composer.json') }}

fail-on-cache-miss: true

- name: Verify bootstrapper resolution

run: pnpm --filter @wpkernel/cli exec tsx scripts/check-bootstrapper-resolution-ci.ts

needs: [lint, build, unit-test, release-pack, bootstrapper]

| Task | Script | VS Code Task | Purpose |

| --------------------- | ---------------------------------------------------------------------------------- | --------------------------------- | ------------------------------------------------------------------------- |

| **Setup** | `pnpm install` | Tasks: Install | Install all dependencies |

| **Build** | `pnpm build` | Tasks: Build All | One-shot production build |

| **Dev mode** | `pnpm dev` | Tasks: Dev: Watch All | Rebuild packages on changes |

| **WordPress** | `pnpm wp:fresh` | Tasks: WordPress: Fresh Start | Start WP + seed test data |

| **Unit tests** | `pnpm test` | Tasks: Test: Unit Tests | Jest tests (no WordPress) |

| **E2E tests** | `pnpm e2e` | Tasks: Test: E2E Tests | Playwright (headless) - **run from root only** |

| **E2E debug** | `pnpm e2e:ui` | Tasks: Test: E2E Tests (UI) | Playwright with UI - **run from root only** |

| **Format** | `pnpm format` | Tasks: Format | Prettier code formatting |

| **Type check** | `pnpm typecheck` | Tasks: TypeCheck: All | TypeScript validation |

| **Release gate** | `pnpm --filter @wpkernel/cli exec tsx scripts/check-release-pack-ci.ts` | Workflow: Release Pack Readiness | Deterministic publish-order + artefact verification (same helper CI runs) |

| **Bootstrapper gate** | `pnpm --filter @wpkernel/cli exec tsx scripts/check-bootstrapper-resolution-ci.ts` | Workflow: Bootstrapper Resolution | Executes the compiled create-wpk bootstrapper in an isolated workspace |

- [x] 2025-11-21 — Updated the pipeline build to run `tsc --noEmit` so Vite preserves ESM `.js` specifiers, preventing the helper bundle from rewriting relative imports without extensions; confirmed `node packages/create-wpk/dist/index.js -- --help` resolves in an isolated `/tmp/wpk-bootstrapper-*` workspace.

- [x] 2025-11-22 — Removed the `WPK_CLI_FORCE_SOURCE` escape hatch, forcing the CLI binary to require compiled dist assets and wiring a `bootstrapper` CI job that runs `scripts/check-bootstrapper-resolution-ci.ts` to execute `packages/create-wpk/dist/index.js -- --help` on every PR.

**Retire.** Source-mode escape hatches (`WPK_CLI_FORCE_SOURCE`) that mask missing bundled files. The bin loader and readiness harness now refuse to honour the flag, and CI exercises the compiled bootstrapper directly so regressions surface immediately.

globalThis.__WPK_CLI_MODULE_URL__ = distInitModule.href;

const { runCli } = await import(distRunModule.href);

handleLoadFailure(error);

function handleLoadFailure(error) {

if (isMissingModuleError(error)) {

console.error(

'[wpk] missing compiled CLI artifacts. ' +

'Build the CLI with "pnpm --filter @wpkernel/cli build" before invoking wpk.'

);

if (error) {

console.error(error);

return;

console.error('[wpk] fatal', error);

function isMissingModuleError(error) {

return Boolean(

error &&

typeof error === 'object' &&

'code' in error &&

error.code === 'ERR_MODULE_NOT_FOUND'

);

import path from 'node:path';

import process from 'node:process';

import { createBootstrapperResolutionReadinessHelper } from '../src/dx/readiness/helpers/bootstrapperResolution';

import type { DxContext } from '../src/dx/context';

interface Reporter {

info: (message: string, context?: unknown) => void;

warn: (message: string, context?: unknown) => void;

error: (message: string, context?: unknown) => void;

debug: (message: string, context?: unknown) => void;

child: (namespace: string) => Reporter;

function createSilentReporter(): Reporter {

return {

info: () => undefined,

warn: () => undefined,

error: () => undefined,

debug: () => undefined,

child: () => createSilentReporter(),

} satisfies Reporter;

function buildContext(): DxContext {

const reporter = createSilentReporter();

return {

reporter,

workspace: null,

environment: {

cwd: process.cwd(),

projectRoot: path.resolve('packages/cli'),

workspaceRoot: null,

},

} satisfies DxContext;

function assertReadyStatus(

stage: 'detection' | 'confirmation' | 'rerun',

status: 'ready' | 'pending',

message?: string

): void {

if (status === 'ready') {

return;

}

const reason = message ?? 'No diagnostic message provided.';

throw new Error(

`bootstrapper-resolution helper ${stage} reported ${status} status: ${reason}`

);

async function main(): Promise<void> {

const helper = createBootstrapperResolutionReadinessHelper();

const context = buildContext();

const detection = await helper.detect(context);

assertReadyStatus('detection', detection.status, detection.message);

const confirmation = await helper.confirm(context, detection.state);

assertReadyStatus(

'confirmation',

confirmation.status,

confirmation.message

);

const rerun = await helper.detect(context);

assertReadyStatus('rerun', rerun.status, rerun.message);

const duration =

rerun.state.lastRun?.durationMs ?? detection.state.lastRun?.durationMs;

console.log(

`Bootstrapper resolved bundled CLI dependencies in ${duration ?? 'unknown'}ms.`

);

main().catch((error) => {

console.error(error);

process.exitCode = 1;