cursedbelt 2.7.0 → 3.0.0

package/src/studio/verification.ts

@@ -1,236 +0,0 @@
-/**
- * The studio moment (03 §3, 04 §1) — the pipeline's fourth run moment finally
- * gets a caller.
- *
- * `verifyAppConfig` has always accepted `moment: 'studio'`; until now nothing in
- * the tree ever passed it. That is why the moment existed only as a fixture: the
- * old studio authored `AppDesignSchema` and never touched the compiler at all.
- * Everything here is about turning ONE `VerifyResult` into something a canvas
- * can paint, and it deliberately adds no rules of its own — a "studio-only"
- * check is exactly the design-time/boot-time skew the single pipeline exists to
- * make impossible.
- *
- * ## Two things this file is careful about
- *
- * **Locating a diagnostic without reading its English.** Stages report
- * `{ instanceId, port, path }`; several also put "Connection 3:" in the message.
- * Parsing that prose to find the wire would make every message a compatibility
- * surface. So targets are resolved from the structured fields only, and a
- * diagnostic that cannot be placed lands on the app rather than being dropped —
- * an unplaceable error must still be visible, or the save gate refuses with
- * nothing on screen to explain why.
- *
- * **The last good manifest.** A config that fails V0 has no manifest, but the
- * canvas still needs ports to draw. `StudioSession` therefore keeps the last
- * manifest that compiled, so a typo in one feature does not blank the wires
- * while you fix it — the same "keep serving the last good bundle" disposition
- * `resolveBootConfig` takes at boot, applied at design time.
- */
-import { verifyAppConfig } from '../verify/pipeline';
-import type {
-  CapabilityProfile,
-  Diagnostic,
-  EffectiveManifest,
-  EngineDescriptor,
-  SourceDecl,
-  VerifyResult,
-} from '../verify/types';
-import type { DraftConfig, StudioDesign } from './document';
-
-/** Where the canvas paints a diagnostic. */
-export type StudioTarget =
-  | { kind: 'app' }
-  | { kind: 'engines' }
-  | { kind: 'instance'; instanceId: string }
-  | { kind: 'feature'; instanceId: string; feature: string }
-  | { kind: 'port'; instanceId: string; port: string }
-  | { kind: 'connection'; index: number };
-
-export interface TargetedDiagnostic extends Diagnostic {
-  target: StudioTarget;
-}
-
-export interface StudioVerification {
-  /** No ERROR diagnostics — the save gate reads exactly this. */
-  ok: boolean;
-  /** The manifest THIS config produced; null when it did not compile. */
-  manifest: EffectiveManifest | null;
-  diagnostics: readonly TargetedDiagnostic[];
-  lastStage: VerifyResult['lastStage'];
-  errorCount: number;
-  warningCount: number;
-  /** Diagnostics by instance id, so a node renders its own badge in O(1). */
-  byInstance: ReadonlyMap<string, readonly TargetedDiagnostic[]>;
-  /** Diagnostics by connection index, for the wire's own badge. */
-  byConnection: ReadonlyMap<number, readonly TargetedDiagnostic[]>;
-  /** Diagnostics that belong to no node or wire — the panel's header section. */
-  appLevel: readonly TargetedDiagnostic[];
-  /**
-   * Set only when the compiler itself failed to run (a throw out of the staging
-   * harvester, a bug in us). Deliberately NOT a diagnostic: `DIAGNOSTIC_CODES`
-   * is a closed vocabulary that fixtures assert against, and "our compiler
-   * crashed" is not a defect in the author's config. It still forces `ok: false`
-   * — a pipeline we could not run has approved nothing.
-   */
-  failure?: string;
-}
-
-export interface StudioVerifyOptions {
-  /** Live host probe. The studio moment reads probed capabilities (04 §1 / J4-B). */
-  capabilities?: CapabilityProfile;
-  sources?: readonly SourceDecl[];
-  engines?: readonly EngineDescriptor[];
-  stagingRoot?: string;
-}
-
-const FEATURE_PATH = /^instances\.(\d+)\.features\.([^.]+)/;
-const INSTANCE_PATH = /^instances\.(\d+)(?:\.|$)/;
-
-/**
- * Place one diagnostic on the canvas from its structured fields alone.
- *
- * Order matters: the most specific placement that RESOLVES wins. An index in a
- * `path` is checked against the live instance list rather than trusted, because
- * V1 reports an unknown connection endpoint using the id the author *typed* —
- * which by definition may name nothing.
- */
-function resolveTarget(diagnostic: Diagnostic, config: DraftConfig): StudioTarget {
-  const instances = config.instances ?? [];
-  const idAt = (raw: string): string | undefined => instances[Number(raw)]?.id;
-  const known = (id: string | undefined): id is string =>
-    id !== undefined && instances.some((instance) => instance.id === id);
-
-  const path = diagnostic.path;
-  if (path) {
-    const feature = FEATURE_PATH.exec(path);
-    if (feature) {
-      const id = idAt(feature[1] as string);
-      if (known(id)) return { kind: 'feature', instanceId: id, feature: feature[2] as string };
-    }
-    const instance = INSTANCE_PATH.exec(path);
-    if (instance) {
-      const id = idAt(instance[1] as string);
-      if (known(id)) return { kind: 'instance', instanceId: id };
-    }
-  }
-
-  if (known(diagnostic.instanceId)) {
-    return diagnostic.port
-      ? { kind: 'port', instanceId: diagnostic.instanceId, port: diagnostic.port }
-      : { kind: 'instance', instanceId: diagnostic.instanceId };
-  }
-
-  // Endpoint-shaped paths name a wire, in TWO forms the stages both use:
-  // a single endpoint (`asset:videos-out`, V1's unresolved-endpoint case,
-  // including when the instance half names nothing — precisely when the wire
-  // rather than the missing node is what the author fixes) and a PAIR
-  // (`asset:videos-out → clips:refresh-in`, which is how every V3 connection
-  // error and V4 cycle reports itself, and which carries no `instanceId` at all).
-  if (path) {
-    const connections = config.connections ?? [];
-    const [head, tail] = path.split(' → ');
-    const index =
-      tail === undefined
-        ? connections.findIndex((wire) => wire.from === path || wire.to === path)
-        : connections.findIndex((wire) => wire.from === head && wire.to === tail);
-    if (index >= 0) return { kind: 'connection', index };
-    if (path === 'engines' || path.startsWith('engines.')) return { kind: 'engines' };
-  }
-  return { kind: 'app' };
-}
-
-function index(diagnostics: readonly TargetedDiagnostic[]): Pick<
-  StudioVerification,
-  'byInstance' | 'byConnection' | 'appLevel'
-> {
-  const byInstance = new Map<string, TargetedDiagnostic[]>();
-  const byConnection = new Map<number, TargetedDiagnostic[]>();
-  const appLevel: TargetedDiagnostic[] = [];
-  for (const diagnostic of diagnostics) {
-    const target = diagnostic.target;
-    if (target.kind === 'connection') {
-      const bucket = byConnection.get(target.index) ?? [];
-      bucket.push(diagnostic);
-      byConnection.set(target.index, bucket);
-    } else if (target.kind === 'app' || target.kind === 'engines') {
-      appLevel.push(diagnostic);
-    } else {
-      const bucket = byInstance.get(target.instanceId) ?? [];
-      bucket.push(diagnostic);
-      byInstance.set(target.instanceId, bucket);
-    }
-  }
-  return { byInstance, byConnection, appLevel };
-}
-
-/** Attach canvas targets to a raw pipeline result. Exported for the session's
- *  own use and for callers that already hold a `VerifyResult`. */
-export function toStudioVerification(result: VerifyResult, config: DraftConfig): StudioVerification {
-  const diagnostics = result.diagnostics.map((diagnostic) => ({
-    ...diagnostic,
-    target: resolveTarget(diagnostic, config),
-  }));
-  return {
-    ok: result.ok,
-    manifest: result.manifest,
-    diagnostics,
-    lastStage: result.lastStage,
-    errorCount: diagnostics.filter((d) => d.severity === 'error').length,
-    warningCount: diagnostics.filter((d) => d.severity === 'warning').length,
-    ...index(diagnostics),
-  };
-}
-
-/**
- * Compile the design through the ONE pipeline at the studio moment.
- *
- * Note what is NOT passed: `deployTarget` capabilities. Studio probes the live
- * host (04 §1) — an author on a machine without ffmpeg should see the
- * `capability-downgrade` their own preview will exhibit, not the target's.
- */
-export async function verifyStudioDesign(
-  design: StudioDesign,
-  options: StudioVerifyOptions = {},
-): Promise<StudioVerification> {
-  const result = await verifyAppConfig({
-    config: design.config,
-    moment: 'studio',
-    ...(options.capabilities === undefined ? {} : { capabilities: options.capabilities }),
-    ...(options.sources === undefined ? {} : { sources: options.sources }),
-    ...(options.engines === undefined ? {} : { engines: options.engines }),
-    ...(options.stagingRoot === undefined ? {} : { stagingRoot: options.stagingRoot }),
-  });
-  return toStudioVerification(result, design.config);
-}
-
-/**
- * The save gate (03 §3: "a structurally invalid app cannot be saved").
- *
- * Warnings never block. A `capability-downgrade` on a laptop without ffmpeg is
- * information about THIS machine, and refusing to save a design because of the
- * hardware you happen to be drawing it on would be the single most infuriating
- * behavior this surface could have.
- */
-export interface SaveDisposition {
-  allowed: boolean;
-  /** The errors standing in the way, already targeted for inline display. */
-  blockers: readonly TargetedDiagnostic[];
-  /** One-line reason, safe to show verbatim in a toast or a 422 body. */
-  reason?: string;
-}
-
-export function saveDisposition(verification: StudioVerification): SaveDisposition {
-  const blockers = verification.diagnostics.filter((d) => d.severity === 'error');
-  if (verification.failure !== undefined)
-    return { allowed: false, blockers, reason: `The design could not be verified: ${verification.failure}` };
-  if (blockers.length === 0) return { allowed: true, blockers: [] };
-  const first = blockers[0] as TargetedDiagnostic;
-  return {
-    allowed: false,
-    blockers,
-    reason:
-      blockers.length === 1
-        ? `${first.code}: ${first.message}`
-        : `${blockers.length} errors block saving, starting with ${first.code}: ${first.message}`,
-  };
-}

package/src/studio/wiring.ts

@@ -1,123 +0,0 @@
-/**
- * What the canvas is allowed to draw (03 §3: "wires are `connections[]`,
- * validated live by V3's token lattice").
- *
- * The old builder's wiring view answered "can these connect?" with its own
- * `canConnect` over plugin `PortSpec`s. This one answers it with the SAME
- * `TokenRegistry.canConnect` V3 uses, over the SAME materialized ports V2
- * produced — so a wire the canvas lets you drop is a wire the compiler accepts,
- * by construction rather than by two implementations agreeing.
- *
- * The load-bearing subtlety is `enabledWhen`. A port whose predicate is false
- * **does not exist** (04 §3, fail-closed): turn `asset.video` off and the video
- * ports are gone from the manifest, so this module stops offering them and any
- * wire already drawn through one becomes a V1 error. That means the palette is
- * derived from `manifest.instances[].ports` — the post-V2 truth — and never from
- * the engine catalog's DECLARED ports, which would happily offer a socket the
- * config has switched off.
- */
-import { baseRegistry } from '../verify/engines';
-import type { TokenRegistry } from '../core/tokens/registry';
-import type { EffectiveManifest, MaterializedPort } from '../verify/types';
-
-/** One end of a wire the author can actually attach to. */
-export interface WirePoint {
-  /** The `'<instanceId>:<portId>'` endpoint string written into `connections[]`. */
-  endpoint: string;
-  instanceId: string;
-  portId: string;
-  direction: 'in' | 'out';
-  tokenId: string;
-  /** `value` ports replay their last payload to late mounts; `signal`s never do. */
-  mode: 'value' | 'signal';
-  /** A required input with no wire is a V3 error — the canvas marks it. */
-  required: boolean;
-}
-
-const pointsOf = (manifest: EffectiveManifest, direction: 'in' | 'out'): WirePoint[] =>
-  manifest.instances.flatMap((instance) =>
-    instance.ports
-      .filter((port: MaterializedPort) => port.enabled && port.spec.direction === direction)
-      .map((port) => ({
-        endpoint: `${instance.id}:${port.spec.id}`,
-        instanceId: instance.id,
-        portId: port.spec.id,
-        direction,
-        tokenId: port.spec.token.id,
-        mode: port.spec.token.mode,
-        required: port.spec.required,
-      })),
-  );
-
-/** Every attachable output — the ends a drag can START from. */
-export const outputs = (manifest: EffectiveManifest): WirePoint[] => pointsOf(manifest, 'out');
-
-/** Every attachable input — the ends a drag can LAND on. */
-export const inputs = (manifest: EffectiveManifest): WirePoint[] => pointsOf(manifest, 'in');
-
-export interface WireVerdict {
-  ok: boolean;
-  /** Present when refused — V3's own wording, so the canvas tooltip and the
-   *  compiler error say the same thing. */
-  message?: string;
-  reason?: 'unknown-produced' | 'unknown-consumed' | 'mode-mismatch' | 'not-a-subtype' | 'duplicate' | 'self';
-}
-
-/**
- * Can this drop be made? Asked on hover, for every candidate input, so it must
- * stay cheap — it is a map lookup plus a walk up the subtype chain.
- *
- * Two refusals are the studio's own rather than V3's, because V3 never sees
- * them: a wire from an instance to itself (the canvas can express it; a port
- * feeding its own sibling port on one node is a cycle nobody means to draw),
- * and an exact duplicate of an existing wire.
- */
-export function canWire(
-  manifest: EffectiveManifest,
-  from: WirePoint,
-  to: WirePoint,
-  registry: TokenRegistry = baseRegistry(),
-): WireVerdict {
-  if (from.instanceId === to.instanceId)
-    return { ok: false, reason: 'self', message: `A wire cannot leave and re-enter '${from.instanceId}'.` };
-  if (manifest.connections.some((wire) => wire.from === from.endpoint && wire.to === to.endpoint))
-    return { ok: false, reason: 'duplicate', message: `'${from.endpoint}' already feeds '${to.endpoint}'.` };
-  const verdict = registry.canConnect(from.tokenId, to.tokenId);
-  return verdict.ok
-    ? { ok: true }
-    : {
-        ok: false,
-        ...(verdict.reason === undefined ? {} : { reason: verdict.reason }),
-        ...(verdict.message === undefined ? {} : { message: verdict.message }),
-      };
-}
-
-/**
- * The inputs a drag from `from` may legally land on — what the canvas highlights
- * green while the author is dragging, so an illegal drop is unreachable rather
- * than merely reported afterwards.
- */
-export function compatibleInputs(
-  manifest: EffectiveManifest,
-  from: WirePoint,
-  registry: TokenRegistry = baseRegistry(),
-): WirePoint[] {
-  return inputs(manifest).filter((candidate) => canWire(manifest, from, candidate, registry).ok);
-}
-
-/**
- * Required inputs with nothing wired into them. V3 reports these as
- * `required-port-unwired` errors at save time; surfacing them on the node while
- * the author is still building is the difference between "the editor told me"
- * and "the build told me".
- */
-export function unwiredRequiredInputs(manifest: EffectiveManifest): WirePoint[] {
-  const wired = new Set(manifest.connections.map((wire) => wire.to));
-  return inputs(manifest).filter((point) => point.required && !wired.has(point.endpoint));
-}
-
-/** Look an endpoint string back up to its port — the canvas's hit-test on an
- *  existing wire's two ends. */
-export function findWirePoint(manifest: EffectiveManifest, endpoint: string): WirePoint | undefined {
-  return [...outputs(manifest), ...inputs(manifest)].find((point) => point.endpoint === endpoint);
-}

package/src/testing/bytes.ts

@@ -1,38 +0,0 @@
-/**
- * `Uint8Array` → a body the DOM types accept, in ONE place.
- *
- * ## The problem this exists to stop being solved five different ways
- *
- * TypeScript 5.7 made `Uint8Array` generic in its buffer: `Uint8Array<ArrayBufferLike>`.
- * `BodyInit` accepts `ArrayBufferView<ArrayBuffer>` — an ArrayBuffer view, NOT a
- * possibly-shared one — so `new Response(bytes)` and `fetch(url, { body: bytes })`
- * stopped compiling for every plain `new Uint8Array([…])` in the repo. Nothing
- * about the runtime changed; the types got more precise about `SharedArrayBuffer`.
- *
- * Two fixes suggest themselves and one of them is a bug:
- *
- *   * `bytes.buffer as ArrayBuffer` — **wrong in general.** `.buffer` is the
- *     WHOLE underlying buffer, so for any view that does not span it (`subarray`,
- *     a slice of a decoder's output, a chunk read off a stream) this silently
- *     sends more bytes than the caller holds. It happens to be right for a
- *     literal `new Uint8Array([1,2,3,4])` and that is exactly what makes it a
- *     trap: it works everywhere it is first tried.
- *   * `bytes as Uint8Array<ArrayBuffer>` — correct, and what this does. It
- *     asserts the one thing the caller actually knows (this buffer is not
- *     shared), changes no lengths, and keeps the view's own offset.
- *
- * Test-only by intent: production code that needs to send bytes should hold a
- * correctly-typed buffer rather than assert one.
- */
-
-/** A `Uint8Array` as a `BodyInit`, preserving byte offset and length. */
-export const asBody = (bytes: Uint8Array): Uint8Array<ArrayBuffer> => bytes as Uint8Array<ArrayBuffer>;
-
-/** `new Response(bytes)` with the assertion applied — the common case. */
-export const bytesResponse = (bytes: Uint8Array, init?: ResponseInit): Response =>
-  new Response(asBody(bytes), init);
-
-/** A readable stream of `bytes` — what the media catalogue's ingest paths take. */
-export const bytesStream = (bytes: Uint8Array | string): ReadableStream<Uint8Array> =>
-  new Response(typeof bytes === 'string' ? asBody(new TextEncoder().encode(bytes)) : asBody(bytes))
-    .body as ReadableStream<Uint8Array>;

package/src/testing/domInspect.spec.ts

@@ -1,79 +0,0 @@
-/**
- * The standing gate on the cheap-DOM-inspect preload.
- *
- * This is a PERFORMANCE assertion, which is normally a bad idea — a wall-clock
- * threshold on a shared CI runner is how you get a flaky suite. It earns its
- * place because the failure it guards is three orders of magnitude wide, not a
- * few percent: without the inspector a single failing `expect` on an attached
- * 50-child element measured 1,576 ms, with it 0.1 ms. The threshold below sits
- * at 150 ms — 10× the headroom a loaded runner could plausibly need, and still
- * 10× under the broken behavior. Nothing between those two numbers is a state
- * this code can actually be in.
- *
- * If this goes red, the preload stopped running or happy-dom moved the class:
- * check `installCheapDomInspect()` is still called AFTER `GlobalRegistrator
- * .register()` in both `happydom.ts` preloads.
- */
-import { describe, expect, test } from 'bun:test';
-
-/** Comfortably above a slow runner, comfortably below the 1,576 ms failure. */
-const BUDGET_MS = 150;
-
-const attachedTree = (children: number): Element => {
-  const el = document.createElement('div');
-  el.className = 'subject';
-  el.innerHTML = '<span>x</span>'.repeat(children);
-  document.body.appendChild(el);
-  return el;
-};
-
-describe('the cheap DOM inspector is installed by the test preload', () => {
-  test('a failing expect on a deep ATTACHED element is fast', () => {
-    const el = attachedTree(50);
-    const started = performance.now();
-    // Deliberately fails: this is the exact shape `waitFor(() => expect(el)
-    // .toBeNull())` runs on every poll.
-    expect(() => expect(el).toBeNull()).toThrow();
-    const elapsed = performance.now() - started;
-    expect(elapsed).toBeLessThan(BUDGET_MS);
-  });
-
-  test('the message shows the MARKUP, not the node object graph', () => {
-    const el = attachedTree(1);
-    let message = '';
-    try {
-      expect(el).toBeNull();
-    } catch (error) {
-      message = (error as Error).message;
-    }
-    expect(message).toContain('<div class="subject">');
-    // The old serializer walked upward through parentNode into the document —
-    // that walk is both the cost and the reason the message was unreadable.
-    expect(message).not.toContain('Symbol(parentNode)');
-    expect(message).not.toContain('HTMLHtmlElement');
-  });
-
-  test('very large markup is elided rather than dumped whole', () => {
-    const el = attachedTree(400);
-    let message = '';
-    try {
-      expect(el).toBeNull();
-    } catch (error) {
-      message = (error as Error).message;
-    }
-    expect(message).toContain('more chars');
-    expect(message.length).toBeLessThan(2000);
-  });
-
-  test('a text node still describes itself', () => {
-    const text = document.createTextNode('hello');
-    let message = '';
-    try {
-      expect(text).toBeNull();
-    } catch (error) {
-      message = (error as Error).message;
-    }
-    expect(message).toContain('#text');
-    expect(message).toContain('hello');
-  });
-});

package/src/testing/domInspect.ts

@@ -1,127 +0,0 @@
-/**
- * Make a happy-dom node CHEAP to serialize, for every `bun test` process in this
- * repo. Imported by `packages/cursedbelt/happydom.ts` and
- * `packages/cursedshell/happydom.ts` — the two test preloads — so it is the ONE
- * place this behavior is defined.
- *
- * ## The bug this exists to not have
- *
- * `expect(received)` builds its failure message EAGERLY, before anything decides
- * whether that message will ever be read. When `received` is a happy-dom node,
- * Bun's inspector walks the node's own object graph — and a happy-dom node holds
- * `[Symbol(parentNode)]`, so the walk goes UPWARD through the parent chain into
- * `HTMLBodyElement` → `HTMLHtmlElement` → `HTMLDocument` → the window, and back
- * down through every sibling subtree it meets on the way.
- *
- * Measured on this repo's own studio spec (2026-07-26):
- *
- * | received value                        | cost of ONE failing `expect` |
- * |---------------------------------------|------------------------------|
- * | `true`                                | 0.1 ms                       |
- * | a plain object                        | 0.0 ms                       |
- * | a detached empty `<div>`              | 9.8 ms                       |
- * | an ATTACHED empty `<div>`             | 29.8 ms                      |
- * | an attached `<div>` with 50 children  | **1,576 ms**                 |
- *
- * That cost is paid on assertions that FAIL, which sounds rare until you notice
- * that `waitFor(() => expect(el).toBeNull())` fails on purpose on every poll
- * until the condition comes true. The studio spec's `settled()` helper spent
- * ~790 ms per mount building error strings that `waitFor` then threw away — 12
- * mounts, ~9.5 s of a 10.5 s file, and on the CI runner the same two assertions
- * blew through Bun's 5,000 ms per-test timeout and turned `main` red.
- *
- * ## The fix
- *
- * Install `nodejs.util.inspect.custom` on happy-dom's `Node.prototype` (the
- * common ancestor of every element, text node, fragment and document), returning
- * TRUNCATED `outerHTML`. Bun's inspector honors that hook and stops walking.
- * Same measurement, after: **1,576 ms → 0.1 ms.**
- *
- * The message gets BETTER as well as faster. What it replaces is not an HTML
- * dump; it is a `[Symbol(listeners)] / [Symbol(parentNode)]` object graph that
- * scrolls for thousands of lines and never shows the markup. `outerHTML` is what
- * someone reading a failure actually wants.
- *
- * ## What this deliberately does NOT do
- *
- * It does not touch `prettyDOM`, `screen.debug()` or any Testing Library output
- * — those have their own serializer and are called only when someone asks for
- * them, so they were never the cost. Only the implicit `expect`/`console.log`
- * path changes.
- */
-
-/** Longest markup we will put in a failure message before eliding the middle. */
-const MAX_MARKUP = 800;
-
-/** Node.nodeType constants, spelled out so this file needs no DOM lib types. */
-const ELEMENT_NODE = 1;
-const TEXT_NODE = 3;
-const COMMENT_NODE = 8;
-const DOCUMENT_NODE = 9;
-const DOCUMENT_FRAGMENT_NODE = 11;
-
-const INSPECT = Symbol.for('nodejs.util.inspect.custom');
-
-interface MinimalNode {
-  nodeType: number;
-  nodeName?: string;
-  outerHTML?: string;
-  innerHTML?: string;
-  data?: string;
-  childNodes?: { length: number };
-}
-
-/** Keep the head and the tail: the opening tag says what it is, the closing tag
- *  says where it ended, and the middle of a 40 KB body is never the useful part. */
-function elide(markup: string): string {
-  if (markup.length <= MAX_MARKUP) return markup;
-  const head = markup.slice(0, MAX_MARKUP - 120);
-  const tail = markup.slice(-100);
-  return `${head}\n  … ${markup.length - MAX_MARKUP + 20} more chars …\n${tail}`;
-}
-
-function describe(node: MinimalNode): string {
-  switch (node.nodeType) {
-    case ELEMENT_NODE:
-      return elide(node.outerHTML ?? `<${(node.nodeName ?? 'element').toLowerCase()} />`);
-    case TEXT_NODE:
-      return `#text ${JSON.stringify(node.data ?? '')}`;
-    case COMMENT_NODE:
-      return `<!--${node.data ?? ''}-->`;
-    case DOCUMENT_NODE:
-      return '#document';
-    case DOCUMENT_FRAGMENT_NODE:
-      return elide(`#document-fragment ${node.innerHTML ?? `(${node.childNodes?.length ?? 0} children)`}`);
-    default:
-      return `${node.nodeName ?? 'Node'}(nodeType ${node.nodeType})`;
-  }
-}
-
-/**
- * Install the cheap inspector. Idempotent, and a no-op when happy-dom has not
- * registered its globals (a pure-logic preload has no `Node`).
- *
- * Call AFTER `GlobalRegistrator.register()` — before it, `globalThis.Node` is
- * whatever Bun ships and patching it would miss the class the specs actually get.
- */
-export function installCheapDomInspect(): void {
-  const NodeCtor = (globalThis as { Node?: { prototype?: object } }).Node;
-  const proto = NodeCtor?.prototype;
-  if (!proto) return;
-  if (Object.hasOwn(proto, INSPECT)) return; // already installed
-
-  Object.defineProperty(proto, INSPECT, {
-    value(this: MinimalNode) {
-      // An inspector that throws turns a readable assertion failure into an
-      // unreadable one, so every branch here is best-effort.
-      try {
-        return describe(this);
-      } catch {
-        return '[unserializable DOM node]';
-      }
-    },
-    configurable: true,
-    enumerable: false,
-    writable: true,
-  });
-}

package/src/testing/fakeFetch.ts

@@ -1,26 +0,0 @@
-/**
- * A `fetch` stand-in that actually satisfies `typeof fetch`.
- *
- * `typeof fetch` is not just a call signature: the DOM lib declares `preconnect`
- * on it, so a bare `async (input) => new Response(…)` is NOT assignable and
- * `as typeof fetch` is refused outright ("neither type sufficiently overlaps").
- * The reflexive workaround is `as unknown as typeof fetch`, and that is the
- * pattern worth stopping: a double assertion silences THIS mismatch and every
- * future one, including a genuine argument-shape error in the fake.
- *
- * This attaches the missing member instead. The result is a real value of the
- * type, so the fake's own `(input, init)` signature stays checked — which is the
- * whole reason to type a fake at all.
- */
-
-/** The part of `fetch` a test actually implements. */
-export type FetchImpl = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-
-/**
- * Wrap a fake so it is a complete `typeof fetch`.
- *
- * `preconnect` is a no-op: it is a resource HINT with no observable result, so a
- * test that triggered one and got nothing has lost nothing.
- */
-export const fakeFetch = (impl: FetchImpl): typeof fetch =>
-  Object.assign(impl, { preconnect: () => undefined }) as typeof fetch;

package/src/testing/index.ts

@@ -1,12 +0,0 @@
-// cursedbelt/testing — test-only helpers shared across every `bun test` process
-// in the fleet. Its own subpath so nothing test-related is reachable from the
-// runtime entrypoints.
-//
-// Exposed on 2026-08-02 so consumers (e.g. cursed-satellites' happydom preload)
-// can `import { installCheapDomInspect } from "cursedbelt/testing"` instead of
-// keeping a ~60-line hand-port of domInspect.ts — the file already lived here,
-// it just had no export.
-export { installCheapDomInspect } from "./domInspect";
-export { asBody, bytesResponse, bytesStream } from "./bytes";
-export { type FetchImpl, fakeFetch } from "./fakeFetch";
-export { hoverHint, tooltipReady } from "./tooltip";