cursedbelt 1.0.0 → 2.5.0

package/src/server/seo/serveHeadInjectedIndex.ts

@@ -1,36 +0,0 @@
-import type { HeadModel } from 'cwip/seo';
-import { injectHead, renderHead, stripBaseTitleAndDescription } from 'cwip/seo';
-import type { Context } from 'hono';
-
-export interface ServeHeadInjectedIndexOptions {
-  // The SPA's index.html, or a (possibly async) loader for it — read once per
-  // request so a caller can hot-reload the file in dev without restarting.
-  html: string | (() => string | Promise<string>);
-  // Looks up the HeadModel for a request path; return undefined to serve the base
-  // shell untouched (no injection) for an unmapped route.
-  resolve: (path: string) => HeadModel | undefined;
-  // Strip the base <title>/<meta name="description"> out of the shell before
-  // injecting the route's own (default true) — otherwise the shell's baseline
-  // title/description would sit alongside the injected ones.
-  stripBase?: boolean;
-}
-
-// Builds a Hono handler that serves `opts.html` with a per-route HeadModel spliced
-// into <head> via cwip's `injectHead`/`renderHead` — a pure string transform, so it
-// runs anywhere Bun does (this repo's Hono/Bun.serve host). An HTMLRewriter-based
-// streaming variant for Cloudflare Workers/Pages Functions can reuse the exact same
-// `renderHead` output later; that seam is intentionally left for a future target
-// rather than built here (see seo-reusable-plan.md §4/§6).
-export const serveHeadInjectedIndex = (opts: ServeHeadInjectedIndexOptions) => {
-  const stripBase = opts.stripBase ?? true;
-
-  return async (c: Context) => {
-    const html = typeof opts.html === 'function' ? await opts.html() : opts.html;
-    const model = opts.resolve(c.req.path);
-    if (!model) return c.html(html);
-
-    const shell = stripBase ? stripBaseTitleAndDescription(html) : html;
-    const headHtml = renderHead(model, { marker: true, indent: '    ' });
-    return c.html(injectHead(shell, headHtml));
-  };
-};

package/src/upload.spec.ts

@@ -1,300 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import {
-  createDropZoneHandlers,
-  formatValidationError,
-  isHeicFile,
-  type UploadProgress,
-  type UploadTransport,
-  uploadFile,
-  uploadFiles,
-  validateFile,
-} from './upload';
-
-// ── validateFile ──────────────────────────────────────────────────────────────
-
-describe('validateFile', () => {
-  const jpegFile = new File(['bytes'], 'photo.jpg', { type: 'image/jpeg' });
-  const bigFile = new File([new Uint8Array(20 * 1024 * 1024 + 1)], 'big.bin', {
-    type: 'application/octet-stream',
-  });
-
-  test('passes with no constraints', () => {
-    expect(validateFile(jpegFile, {})).toEqual({ ok: true });
-  });
-
-  test('passes when MIME matches exact pattern', () => {
-    expect(validateFile(jpegFile, { accept: ['image/jpeg'] })).toEqual({ ok: true });
-  });
-
-  test('passes when MIME matches glob prefix image/*', () => {
-    expect(validateFile(jpegFile, { accept: ['image/*'] })).toEqual({ ok: true });
-  });
-
-  test('fails when MIME does not match any pattern', () => {
-    const res = validateFile(jpegFile, { accept: ['video/*'] });
-    expect(res.ok).toBe(false);
-    if (res.ok) return;
-    expect(res.error.kind).toBe('type');
-  });
-
-  test('fails when file exceeds maxBytes', () => {
-    const res = validateFile(bigFile, { maxBytes: 10 * 1024 * 1024 });
-    expect(res.ok).toBe(false);
-    if (res.ok) return;
-    expect(res.error.kind).toBe('size');
-  });
-
-  test('passes size when file is exactly maxBytes', () => {
-    const exact = new File([new Uint8Array(1024)], 'exact.bin', {
-      type: 'application/octet-stream',
-    });
-    expect(validateFile(exact, { maxBytes: 1024 })).toEqual({ ok: true });
-  });
-
-  test('formatValidationError returns human-readable messages', () => {
-    const typeErr = validateFile(jpegFile, { accept: ['video/*'] });
-    if (typeErr.ok) throw new Error('expected error');
-    expect(formatValidationError(typeErr.error)).toContain('image/jpeg');
-
-    const sizeErr = validateFile(bigFile, { maxBytes: 1024 });
-    if (sizeErr.ok) throw new Error('expected error');
-    expect(formatValidationError(sizeErr.error)).toContain('MB');
-  });
-});
-
-// ── isHeicFile ────────────────────────────────────────────────────────────────
-
-describe('isHeicFile', () => {
-  test('detects image/heic MIME', () => {
-    expect(isHeicFile(new File([''], 'photo.heic', { type: 'image/heic' }))).toBe(true);
-  });
-
-  test('detects image/heif MIME', () => {
-    expect(isHeicFile(new File([''], 'photo.heif', { type: 'image/heif' }))).toBe(true);
-  });
-
-  test('detects .heic extension when MIME is missing', () => {
-    expect(isHeicFile(new File([''], 'photo.heic', { type: '' }))).toBe(true);
-  });
-
-  test('returns false for normal JPEG', () => {
-    expect(isHeicFile(new File([''], 'photo.jpg', { type: 'image/jpeg' }))).toBe(false);
-  });
-});
-
-// ── uploadFile ────────────────────────────────────────────────────────────────
-
-function makeTransport(
-  outcome: Awaited<ReturnType<UploadTransport['uploadAuto']>>,
-): UploadTransport {
-  return {
-    uploadAuto: async (_file, _opts) => outcome,
-    upload: async (_file, _opts) => outcome,
-  };
-}
-
-const FAKE_FILE_RECORD = {
-  id: 'f1',
-  name: 'photo.jpg',
-  mime: 'image/jpeg',
-  size: 100,
-  fileType: 'image',
-  tags: [],
-  processingStatus: 'ready',
-};
-
-describe('uploadFile', () => {
-  test('returns ok:true with file record on success', async () => {
-    const transport = makeTransport({ ok: true, file: FAKE_FILE_RECORD });
-    const res = await uploadFile(new File(['x'], 'photo.jpg', { type: 'image/jpeg' }), {
-      transport,
-    });
-    expect(res.ok).toBe(true);
-    if (!res.ok) return;
-    expect(res.file.id).toBe('f1');
-  });
-
-  test('emits progress events: validating → uploading → done', async () => {
-    const transport = makeTransport({ ok: true, file: FAKE_FILE_RECORD });
-    const phases: string[] = [];
-    await uploadFile(new File(['x'], 'photo.jpg', { type: 'image/jpeg' }), {
-      transport,
-      onProgress: (p: UploadProgress) => phases.push(p.phase),
-    });
-    expect(phases).toEqual(['validating', 'uploading', 'done']);
-  });
-
-  test('rejects invalid MIME before calling transport', async () => {
-    let called = false;
-    const transport: UploadTransport = {
-      uploadAuto: async () => {
-        called = true;
-        return { ok: true, file: FAKE_FILE_RECORD };
-      },
-      upload: async () => {
-        called = true;
-        return { ok: true, file: FAKE_FILE_RECORD };
-      },
-    };
-    const res = await uploadFile(new File(['x'], 'vid.mp4', { type: 'video/mp4' }), {
-      transport,
-      constraints: { accept: ['image/*'] },
-    });
-    expect(res.ok).toBe(false);
-    expect(called).toBe(false);
-  });
-
-  test('rejects oversized file before calling transport', async () => {
-    let called = false;
-    const transport: UploadTransport = {
-      uploadAuto: async () => {
-        called = true;
-        return { ok: true, file: FAKE_FILE_RECORD };
-      },
-      upload: async () => {
-        called = true;
-        return { ok: true, file: FAKE_FILE_RECORD };
-      },
-    };
-    const big = new File([new Uint8Array(1025)], 'big.jpg', { type: 'image/jpeg' });
-    const res = await uploadFile(big, { transport, constraints: { maxBytes: 1024 } });
-    expect(res.ok).toBe(false);
-    expect(called).toBe(false);
-  });
-
-  test('propagates transport error as ok:false', async () => {
-    const transport = makeTransport({ ok: false, error: 'network failure' });
-    const res = await uploadFile(new File(['x'], 'x.jpg', { type: 'image/jpeg' }), { transport });
-    expect(res.ok).toBe(false);
-    if (res.ok) return;
-    expect(res.error).toBe('network failure');
-  });
-
-  test('marks heicConverted:true for HEIC files', async () => {
-    const transport = makeTransport({
-      ok: true,
-      file: { ...FAKE_FILE_RECORD, mime: 'image/heic' },
-    });
-    const res = await uploadFile(new File(['x'], 'photo.heic', { type: 'image/heic' }), {
-      transport,
-    });
-    expect(res.ok).toBe(true);
-    if (!res.ok) return;
-    expect(res.file.heicConverted).toBe(true);
-  });
-
-  test('passes tags to transport', async () => {
-    let capturedTags: string[] | undefined;
-    const transport: UploadTransport = {
-      uploadAuto: async (_file, opts) => {
-        capturedTags = opts?.tags;
-        return { ok: true, file: FAKE_FILE_RECORD };
-      },
-      upload: async () => ({ ok: true, file: FAKE_FILE_RECORD }),
-    };
-    await uploadFile(new File(['x'], 'x.jpg', { type: 'image/jpeg' }), {
-      transport,
-      tags: ['travel', 'portrait'],
-    });
-    expect(capturedTags).toEqual(['travel', 'portrait']);
-  });
-});
-
-// ── uploadFiles ───────────────────────────────────────────────────────────────
-
-describe('uploadFiles', () => {
-  test('returns all results when all succeed', async () => {
-    const transport = makeTransport({ ok: true, file: FAKE_FILE_RECORD });
-    const files = [
-      new File(['a'], 'a.jpg', { type: 'image/jpeg' }),
-      new File(['b'], 'b.jpg', { type: 'image/jpeg' }),
-    ];
-    const { results, firstError } = await uploadFiles(files, { transport });
-    expect(results).toHaveLength(2);
-    expect(firstError).toBeNull();
-  });
-
-  test('stops at the first error and reports it', async () => {
-    let callCount = 0;
-    const transport: UploadTransport = {
-      uploadAuto: async () => {
-        callCount++;
-        return callCount === 1
-          ? { ok: false, error: 'failed' }
-          : { ok: true, file: FAKE_FILE_RECORD };
-      },
-      upload: async () => ({ ok: true, file: FAKE_FILE_RECORD }),
-    };
-    const files = [
-      new File(['a'], 'a.jpg', { type: 'image/jpeg' }),
-      new File(['b'], 'b.jpg', { type: 'image/jpeg' }),
-    ];
-    const { results, firstError } = await uploadFiles(files, { transport });
-    expect(firstError).toBe('failed');
-    expect(results).toHaveLength(1);
-    expect(callCount).toBe(1);
-  });
-});
-
-// ── createDropZoneHandlers ────────────────────────────────────────────────────
-
-describe('createDropZoneHandlers', () => {
-  function makeDropEvent(files: File[]): DragEvent {
-    const dt = {
-      files: Object.assign(files, {
-        item: (i: number) => files[i] ?? null,
-        [Symbol.iterator]: files[Symbol.iterator].bind(files),
-      }) as unknown as FileList,
-    };
-    return {
-      preventDefault: () => {},
-      dataTransfer: dt,
-    } as unknown as DragEvent;
-  }
-
-  test('onDrop delivers files to onFiles', () => {
-    const received: File[] = [];
-    const { onDrop } = createDropZoneHandlers({ onFiles: (fs) => received.push(...fs) });
-    const file = new File(['x'], 'x.txt', { type: 'text/plain' });
-    onDrop(makeDropEvent([file]));
-    expect(received).toHaveLength(1);
-    expect(received[0]!.name).toBe('x.txt');
-  });
-
-  test('onDrop filters by accept when provided', () => {
-    const received: File[] = [];
-    const { onDrop } = createDropZoneHandlers({
-      onFiles: (fs) => received.push(...fs),
-      accept: ['image/*'],
-    });
-    const img = new File([''], 'a.jpg', { type: 'image/jpeg' });
-    const doc = new File([''], 'b.txt', { type: 'text/plain' });
-    onDrop(makeDropEvent([img, doc]));
-    expect(received).toHaveLength(1);
-    expect(received[0]!.name).toBe('a.jpg');
-  });
-
-  test('onDragOver calls onEnter', () => {
-    let entered = false;
-    const { onDragOver } = createDropZoneHandlers({
-      onFiles: () => {},
-      onEnter: () => {
-        entered = true;
-      },
-    });
-    onDragOver({ preventDefault: () => {} } as DragEvent);
-    expect(entered).toBe(true);
-  });
-
-  test('onDragLeave calls onLeave', () => {
-    let left = false;
-    const { onDragLeave } = createDropZoneHandlers({
-      onFiles: () => {},
-      onLeave: () => {
-        left = true;
-      },
-    });
-    onDragLeave({ preventDefault: () => {} } as DragEvent);
-    expect(left).toBe(true);
-  });
-});

package/src/upload.ts

@@ -1,288 +0,0 @@
-// cursedbelt/upload — framework-agnostic upload primitive
-//
-// Sits above the transport (fileUploadClient) and below the UI layer. Provides:
-//   • Client-side validation (MIME type + byte size)
-//   • Progress events during upload
-//   • Drag-and-drop drop-zone wiring (pure DOM, no React)
-//   • HEIC/HEIF mobile-photo detection (conversion is server-side)
-//   • Typed UploadResult contract consumed by MediaUploadControl and app plugins
-//
-// Consumers that want the raw transport client import createFileUploadClient from
-// 'cursedbelt/react/media'; this module layers validation + progress on top.
-
-// ── MIME / HEIC ──────────────────────────────────────────────────────────────
-
-/** True for iPhone HEIC/HEIF images — the server converts these to JPEG. */
-export function isHeicFile(file: File): boolean {
-  const mime = file.type.toLowerCase();
-  if (mime === 'image/heic' || mime === 'image/heif') return true;
-  const name = file.name.toLowerCase();
-  return name.endsWith('.heic') || name.endsWith('.heif');
-}
-
-// ── Validation ───────────────────────────────────────────────────────────────
-
-export interface UploadConstraints {
-  /** Allowed MIME types (exact match or glob prefix, e.g. 'image/*'). If omitted, any type. */
-  accept?: string[];
-  /** Maximum file size in bytes. If omitted, no cap. */
-  maxBytes?: number;
-}
-
-export type ValidationError =
-  | { kind: 'type'; file: string; mime: string; accept: string[] }
-  | { kind: 'size'; file: string; bytes: number; maxBytes: number };
-
-export type ValidationResult = { ok: true } | { ok: false; error: ValidationError };
-
-function mimeMatches(mime: string, pattern: string): boolean {
-  if (pattern === mime) return true;
-  if (pattern.endsWith('/*')) {
-    return mime.startsWith(pattern.slice(0, -1));
-  }
-  return false;
-}
-
-export function validateFile(file: File, constraints: UploadConstraints): ValidationResult {
-  if (constraints.accept?.length) {
-    const mime = file.type || 'application/octet-stream';
-    const ok = constraints.accept.some((p) => mimeMatches(mime, p));
-    if (!ok)
-      return {
-        ok: false,
-        error: { kind: 'type', file: file.name, mime, accept: constraints.accept },
-      };
-  }
-  if (constraints.maxBytes !== undefined && file.size > constraints.maxBytes) {
-    return {
-      ok: false,
-      error: { kind: 'size', file: file.name, bytes: file.size, maxBytes: constraints.maxBytes },
-    };
-  }
-  return { ok: true };
-}
-
-export function formatValidationError(error: ValidationError): string {
-  if (error.kind === 'type') {
-    return `"${error.file}" is not an accepted file type (${error.mime}). Accepted: ${error.accept.join(', ')}.`;
-  }
-  return `"${error.file}" is too large (${(error.bytes / 1024 / 1024).toFixed(1)} MB). Max: ${(error.maxBytes / 1024 / 1024).toFixed(1)} MB.`;
-}
-
-// ── Progress ──────────────────────────────────────────────────────────────────
-
-export type UploadProgress =
-  | { phase: 'validating' }
-  | { phase: 'uploading'; loaded: number; total: number }
-  | { phase: 'chunking'; chunk: number; total: number }
-  | { phase: 'done' }
-  | { phase: 'error'; message: string };
-
-// ── Result contract ───────────────────────────────────────────────────────────
-
-/** Subset of the server FileRecord that upload consumers care about. */
-export interface UploadedFile {
-  id: string;
-  name: string;
-  mime: string;
-  size: number;
-  fileType: string;
-  tags: string[];
-  processingStatus: string;
-  /** True when the server accepted a HEIC/HEIF file for conversion. */
-  heicConverted?: boolean;
-}
-
-export type UploadResult =
-  | { ok: true; file: UploadedFile }
-  | { ok: false; error: string; validationError?: ValidationError };
-
-// ── Transport interface (injected — keeps this module framework-agnostic) ─────
-
-/** Minimal transport interface the pipeline requires — satisfied by FileUploadClient. */
-export interface UploadTransport {
-  uploadAuto(
-    file: File,
-    opts?: { tags?: string[] },
-  ): Promise<
-    | {
-        ok: true;
-        file?: {
-          id: string;
-          name: string;
-          mime: string;
-          size: number;
-          fileType: string;
-          tags: string[];
-          processingStatus: string;
-        };
-      }
-    | { ok: false; error: string }
-  >;
-  upload(
-    file: File | Blob,
-    opts?: { name?: string; tags?: string[] },
-  ): Promise<
-    | {
-        ok: true;
-        file?: {
-          id: string;
-          name: string;
-          mime: string;
-          size: number;
-          fileType: string;
-          tags: string[];
-          processingStatus: string;
-        };
-      }
-    | { ok: false; error: string }
-  >;
-}
-
-// ── Upload pipeline ───────────────────────────────────────────────────────────
-
-export interface UploadPipelineOptions {
-  transport: UploadTransport;
-  constraints?: UploadConstraints;
-  tags?: string[];
-  onProgress?: (progress: UploadProgress) => void;
-}
-
-export async function uploadFile(file: File, opts: UploadPipelineOptions): Promise<UploadResult> {
-  const { transport, constraints = {}, tags, onProgress } = opts;
-  const emit = (p: UploadProgress): void => {
-    onProgress?.(p);
-  };
-
-  emit({ phase: 'validating' });
-  const validation = validateFile(file, constraints);
-  if (!validation.ok) {
-    const msg = formatValidationError(validation.error);
-    emit({ phase: 'error', message: msg });
-    return { ok: false, error: msg, validationError: validation.error };
-  }
-
-  emit({ phase: 'uploading', loaded: 0, total: file.size });
-  const heic = isHeicFile(file);
-
-  const res = await transport.uploadAuto(file, { tags }).catch((e: unknown) => ({
-    ok: false as const,
-    error: e instanceof Error ? e.message : 'upload failed',
-  }));
-
-  if (!res.ok) {
-    emit({ phase: 'error', message: res.error });
-    return { ok: false, error: res.error };
-  }
-
-  const f = res.file;
-  if (!f) {
-    emit({ phase: 'error', message: 'upload succeeded but no file record returned' });
-    return { ok: false, error: 'upload succeeded but no file record returned' };
-  }
-
-  emit({ phase: 'done' });
-  return {
-    ok: true,
-    file: {
-      id: f.id,
-      name: f.name,
-      mime: f.mime,
-      size: f.size,
-      fileType: f.fileType,
-      tags: f.tags,
-      processingStatus: f.processingStatus,
-      heicConverted: heic,
-    },
-  };
-}
-
-/** Upload multiple files sequentially, stopping on the first error. */
-export async function uploadFiles(
-  files: File[],
-  opts: UploadPipelineOptions,
-): Promise<{ results: UploadResult[]; firstError: string | null }> {
-  const results: UploadResult[] = [];
-  for (const file of files) {
-    const result = await uploadFile(file, opts);
-    results.push(result);
-    if (!result.ok) return { results, firstError: result.error };
-  }
-  return { results, firstError: null };
-}
-
-// ── Drag-and-drop helpers (pure DOM, no framework) ────────────────────────────
-
-export interface DropZoneHandlers {
-  onDragOver: (e: DragEvent) => void;
-  onDragLeave: (e: DragEvent) => void;
-  onDrop: (e: DragEvent) => void;
-}
-
-export interface DropZoneOptions {
-  /** Invoked with accepted files dropped onto the zone. */
-  onFiles: (files: File[]) => void;
-  /** Invoked when a drag enters the zone (for visual feedback). */
-  onEnter?: () => void;
-  /** Invoked when a drag leaves or is dropped (for visual feedback). */
-  onLeave?: () => void;
-  /** Optionally filter dropped items by MIME — mismatched files are silently excluded. */
-  accept?: string[];
-}
-
-/**
- * Returns plain event handler objects that wire a DOM element as a drop zone.
- * Attach them with addEventListener or pass to a React component's onDrag* props.
- *
- * @example
- * const { onDragOver, onDragLeave, onDrop } = createDropZoneHandlers({ onFiles });
- * el.addEventListener('dragover', onDragOver);
- * el.addEventListener('dragleave', onDragLeave);
- * el.addEventListener('drop', onDrop);
- */
-export function createDropZoneHandlers(opts: DropZoneOptions): DropZoneHandlers {
-  const { onFiles, onEnter, onLeave, accept } = opts;
-
-  const onDragOver = (e: DragEvent): void => {
-    e.preventDefault();
-    onEnter?.();
-  };
-
-  const onDragLeave = (e: DragEvent): void => {
-    e.preventDefault();
-    onLeave?.();
-  };
-
-  const onDrop = (e: DragEvent): void => {
-    e.preventDefault();
-    onLeave?.();
-    const items = e.dataTransfer?.files;
-    if (!items?.length) return;
-    let files = Array.from(items);
-    if (accept?.length) {
-      files = files.filter((f) => accept.some((p) => mimeMatches(f.type || '', p)));
-    }
-    if (files.length) onFiles(files);
-  };
-
-  return { onDragOver, onDragLeave, onDrop };
-}
-
-/**
- * Mount a drop zone on `el`, returning an unmount function.
- *
- * @example
- * const unmount = mountDropZone(containerEl, { onFiles, accept: ['image/*'] });
- * // later: unmount();
- */
-export function mountDropZone(el: HTMLElement, opts: DropZoneOptions): () => void {
-  const { onDragOver, onDragLeave, onDrop } = createDropZoneHandlers(opts);
-  el.addEventListener('dragover', onDragOver);
-  el.addEventListener('dragleave', onDragLeave);
-  el.addEventListener('drop', onDrop);
-  return () => {
-    el.removeEventListener('dragover', onDragOver);
-    el.removeEventListener('dragleave', onDragLeave);
-    el.removeEventListener('drop', onDrop);
-  };
-}

package/src/verify/runtime/index.ts

@@ -1,64 +0,0 @@
-/**
- * `cursedbelt/verify/runtime` — V7: verify-mode boot, the probe suite, and the
- * PID jail that guarantees a run leaves nothing behind (04 §2 V7, §5.7).
- *
- * Server-side only (Bun + Hono); the static V0–V6 compiler in `cursedbelt/verify`
- * has no runtime dependencies and runs anywhere.
- */
-export {
-  type CliOptions,
-  type CliResult,
-  type CorpusFailure,
-  parseArgs,
-  runCli,
-  runCorpus,
-  writeArtifacts,
-} from './cli';
-export { type HostProbeOptions, probeHostCapabilities } from './hostCapabilities';
-export {
-  createFakeSpawn,
-  createVerifyContext,
-  createVerifyGuard,
-  createVerifyExec,
-  createVerifyJobBroker,
-  createVerifyCognitiveDriver,
-  createVerifyStorage,
-  createVerifyTelemetry,
-  VERIFY_COMMANDS,
-  type VerifyContext,
-  type VerifyContextOptions,
-  type VerifyGuard,
-} from './verifyContext';
-export {
-  createVerifyAssetService,
-  createVerifyDevService,
-  createVerifyGuardService,
-  createVerifyKnowledgeService,
-  createVerifySystemService,
-  PRIVATE_ITEM_IDS,
-  PUBLIC_ITEM_IDS,
-} from './verifyServices';
-export {
-  CORE_PROBES,
-  crossTabLockProbe,
-  deepLinkTenantProbe,
-  eventLoopGuardProbe,
-  execJailProbe,
-  injectionGuardProbe,
-  instanceIsolationProbe,
-  integrityTamperProbe,
-  lastGoodProbe,
-  layoutProbe,
-  lifecycleProbe,
-  type Probe,
-  type ProbeContext,
-  privateModeProbe,
-  rbacProbe,
-  reconnectProbe,
-  routeSurfaceProbe,
-  securityHeaderProbe,
-  wireSmokeProbe,
-} from './probes';
-export { isPortBound, ProcessJail, runJailed, type SweepReport, type TrackedChild } from './processJail';
-export { type ProbeRunResult, type RunProbesOptions, runVerifyProbes, VERIFY_TIMEOUT_MS } from './runner';
-export { createVerifyServer, type Role, type VerifyClaims, type VerifyServer, type VerifyServerOptions } from './verifyServer';