@cimplify/sdk 0.108.0 → 0.110.2

package/dist/terrain-C-XC1Oui.d.mts

@@ -0,0 +1,429 @@
+import { A as AiGenerateRequest, j as AiRun } from './local-D8_I6UeL.mjs';
+import { C as Chemistry, b as DefineResult, I as InputActions } from './game-Bx8onkhX.mjs';
+import { V as Vec3, f as Vec3Like, N as NodeId, D as DeviceTier, T as TerrainPort, B as BrushOp, g as NoiseKind } from './backend-gUCzs5Kg.mjs';
+
+declare const CHEMISTRY_PROMPT = "chemistry_invent";
+declare const CHEMISTRY_SCHEMA = "chemistry_proposal";
+declare const MAX_KNOWN_CHARS = 200;
+declare const MAX_NAME = 32;
+declare const MAX_FORMULA = 24;
+declare const MAX_TERMS = 4;
+declare const MAX_SPECIES = 2;
+type Json = string | number | boolean | readonly Json[] | {
+    readonly [key: string]: Json;
+};
+declare const PROPOSAL_SCHEMA: Json;
+declare const CHEMISTRY_TEMPLATE: string;
+declare const CHEMISTRY_AI_CAPABILITY = "Describe a reaction and the world's chemistry decides whether it can happen";
+declare function chemistryAiSection(): string;
+declare function chemistryAiToml(): string;
+interface ChemistryAi {
+    generate(request: AiGenerateRequest): Promise<AiRun>;
+}
+interface ReactionIdea {
+    readonly description: string;
+    readonly materials: string;
+    readonly requestKey: string;
+}
+declare function reactionRequest(idea: ReactionIdea): AiGenerateRequest;
+interface ProposedTerm {
+    readonly material: string;
+    readonly count: number;
+    readonly phase?: "solid" | "liquid" | "gas" | "any";
+}
+interface ProposedMaterial {
+    readonly name: string;
+    readonly formula: string;
+    readonly formation_kj: number;
+    readonly melt_k?: number;
+    readonly boil_k?: number;
+    readonly density?: number;
+    readonly groups?: readonly string[];
+    readonly colour?: string;
+    readonly ignition_k?: number;
+}
+interface Proposal {
+    readonly materials?: readonly ProposedMaterial[];
+    readonly reaction: {
+        readonly name: string;
+        readonly reactants: readonly ProposedTerm[];
+        readonly products: readonly ProposedTerm[];
+        readonly catalyst?: string;
+        readonly above_k?: number;
+        readonly activation_kj?: number;
+        readonly claimed_kj?: number;
+    };
+}
+declare function proposalText(p: Proposal): string;
+declare function knownMaterials(chemistry: Chemistry): string;
+declare function proposeReaction(chemistry: Chemistry, ai: ChemistryAi, idea: Omit<ReactionIdea, "materials">): Promise<DefineResult | {
+    readonly ok: false;
+    readonly line: 0;
+    readonly refusal: "malformed";
+    readonly reason: string;
+}>;
+
+declare class Box3 {
+    readonly min: Vec3;
+    readonly max: Vec3;
+    set(min: Vec3Like, max: Vec3Like): this;
+    setValues(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): this;
+    copy(box: Box3): this;
+    makeEmpty(): this;
+    isEmpty(): boolean;
+    expandByPoint(p: Vec3Like): this;
+    expandByXyz(x: number, y: number, z: number): this;
+    expandByScalar(s: number): this;
+    setFromArray(positions: ArrayLike<number>, start?: number, count?: number, stride?: number): this;
+    union(box: Box3): this;
+    intersect(box: Box3): this;
+    center(out: Vec3): Vec3;
+    size(out: Vec3): Vec3;
+    containsPoint(p: Vec3Like): boolean;
+    containsBox(box: Box3): boolean;
+    intersectsBox(box: Box3): boolean;
+    intersectsSphere(sphere: Sphere): boolean;
+    intersectsPlane(plane: Plane): boolean;
+    clampPoint(p: Vec3Like, out: Vec3): Vec3;
+    distanceSquaredToPoint(p: Vec3Like): number;
+    distanceToPoint(p: Vec3Like): number;
+    boundingSphere(out: Sphere): Sphere;
+    corner(index: number, out: Vec3): Vec3;
+    applyMat4(m: ArrayLike<number>, o: number): this;
+    translate(offset: Vec3Like): this;
+}
+declare class Sphere {
+    readonly center: Vec3;
+    radius: number;
+    set(center: Vec3Like, radius: number): this;
+    copy(sphere: Sphere): this;
+    makeEmpty(): this;
+    isEmpty(): boolean;
+    setFromArray(positions: ArrayLike<number>, scratch: Box3, stride?: number): this;
+    containsPoint(p: Vec3Like): boolean;
+    distanceToPoint(p: Vec3Like): number;
+    intersectsSphere(sphere: Sphere): boolean;
+    intersectsBox(box: Box3): boolean;
+    intersectsPlane(plane: Plane): boolean;
+    expandByPoint(p: Vec3Like): this;
+    union(sphere: Sphere): this;
+    applyMat4(m: ArrayLike<number>, o: number): this;
+}
+declare class Plane {
+    readonly normal: Vec3;
+    constant: number;
+    set(normal: Vec3Like, constant: number): this;
+    setComponents(x: number, y: number, z: number, w: number): this;
+    setFromNormalAndPoint(normal: Vec3Like, point: Vec3Like): this;
+    setFromCoplanarPoints(a: Vec3Like, b: Vec3Like, c: Vec3Like): this;
+    copy(plane: Plane): this;
+    normalize(): this;
+    negate(): this;
+    distanceToPoint(p: Vec3Like): number;
+    projectPoint(p: Vec3Like, out: Vec3): Vec3;
+    coplanarPoint(out: Vec3): Vec3;
+    intersectLine(start: Vec3Like, end: Vec3Like, out: Vec3): boolean;
+    applyMat4(m: ArrayLike<number>, o: number, normalMatrix: ArrayLike<number>, no: number): this;
+    toTuple(out: Float32Array | Float64Array, offset?: number): void;
+}
+declare class Ray {
+    readonly origin: Vec3;
+    readonly direction: Vec3;
+    set(origin: Vec3Like, direction: Vec3Like): this;
+    copy(ray: Ray): this;
+    at(t: number, out: Vec3): Vec3;
+    lookAt(target: Vec3Like): this;
+    closestPointToPoint(p: Vec3Like, out: Vec3): Vec3;
+    distanceSquaredToPoint(p: Vec3Like): number;
+    distanceToPlane(plane: Plane): number;
+    intersectPlane(plane: Plane, out: Vec3): boolean;
+    intersectSphereDistance(sphere: Sphere): number;
+    intersectSphere(sphere: Sphere, out: Vec3): boolean;
+    intersectBoxDistance(box: Box3): number;
+    intersectBox(box: Box3, out: Vec3): boolean;
+    intersectTriangleDistance(a: Vec3Like, b: Vec3Like, c: Vec3Like, backfaceCulling?: boolean): number;
+    applyMat4(m: ArrayLike<number>, o: number): this;
+}
+declare class Frustum {
+    readonly planes: readonly Plane[];
+    setFromProjectionMatrix(m: ArrayLike<number>, o: number): this;
+    copy(frustum: Frustum): this;
+    containsPoint(p: Vec3Like): boolean;
+    intersectsSphere(sphere: Sphere): boolean;
+    intersectsBox(box: Box3): boolean;
+}
+declare class Triangle {
+    readonly a: Vec3;
+    readonly b: Vec3;
+    readonly c: Vec3;
+    set(a: Vec3Like, b: Vec3Like, c: Vec3Like): this;
+    setFromArray(positions: ArrayLike<number>, i0: number, i1: number, i2: number): this;
+    normal(out: Vec3): Vec3;
+    area(): number;
+    midpoint(out: Vec3): Vec3;
+    plane(out: Plane): Plane;
+    barycoord(p: Vec3Like, out: Vec3): boolean;
+    containsPoint(p: Vec3Like): boolean;
+    closestPointToPoint(p: Vec3Like, out: Vec3): Vec3;
+}
+declare class Spherical {
+    radius: number;
+    polar: number;
+    azimuth: number;
+    set(radius: number, polar: number, azimuth: number): this;
+    makeSafe(): this;
+    setFromVector(v: Vec3Like): this;
+    toVector(out: Vec3): Vec3;
+}
+declare class Cylindrical {
+    radius: number;
+    theta: number;
+    y: number;
+    set(radius: number, theta: number, y: number): this;
+    setFromVector(v: Vec3Like): this;
+    toVector(out: Vec3): Vec3;
+}
+
+interface InputSurface {
+    addEventListener(type: string, listener: (event: Event) => void, options?: AddEventListenerOptions): void;
+    removeEventListener(type: string, listener: (event: Event) => void): void;
+    getBoundingClientRect(): DOMRect;
+}
+interface DomInputOptions {
+    readonly wheel?: boolean;
+    readonly preventWheel?: boolean;
+    readonly orientation?: boolean;
+    readonly preventContextMenu?: boolean;
+}
+declare function wheelPixels(delta: number, mode: number, pageHeight: number): number;
+declare function attachDomInput(input: InputActions, surface: InputSurface, keyTarget: EventTarget, options?: DomInputOptions): () => void;
+interface PointerLockTarget {
+    requestPointerLock(): Promise<void> | void;
+}
+interface PointerLockDocument {
+    readonly pointerLockElement: Element | null;
+    exitPointerLock(): void;
+}
+declare function requestPointerLock(target: PointerLockTarget): Promise<boolean>;
+declare function exitPointerLock(doc: PointerLockDocument): void;
+declare function isPointerLocked(doc: PointerLockDocument, target: unknown): boolean;
+declare function requestOrientationPermission(source?: unknown): Promise<boolean>;
+declare function screenOrientationDegrees(source?: unknown): number;
+interface GamepadButtonLike {
+    readonly value: number;
+    readonly pressed: boolean;
+}
+interface GamepadEffectLike {
+    playEffect(type: "dual-rumble", params: {
+        duration: number;
+        strongMagnitude: number;
+        weakMagnitude: number;
+        startDelay?: number;
+    }): Promise<unknown>;
+}
+interface GamepadLike {
+    readonly connected: boolean;
+    readonly buttons: readonly GamepadButtonLike[];
+    readonly axes: readonly number[];
+    readonly vibrationActuator?: GamepadEffectLike | null;
+}
+interface GamepadSource {
+    getGamepads(): ArrayLike<GamepadLike | null>;
+}
+declare class GamepadPoller {
+    readonly index: number;
+    private readonly source;
+    private readonly buttons;
+    private readonly axes;
+    private connectedState;
+    constructor(source: GamepadSource, index?: number);
+    get connected(): boolean;
+    poll(input: InputActions, timeMs: number): boolean;
+    rumble(strong: number, weak: number, durationMs: number): boolean;
+    private pad;
+}
+
+type ProjectionMode = "perspective" | "orthographic";
+interface NodeMatrixSource {
+    readNodeMatrix(node: NodeId, out: Float32Array, offset?: number): void;
+}
+interface CameraProjectionOptions {
+    readonly mode?: ProjectionMode;
+    readonly fov?: number;
+    readonly near?: number;
+    readonly far?: number;
+    readonly height?: number;
+    readonly zoom?: number;
+    readonly width?: number;
+    readonly viewportHeight?: number;
+}
+interface ViewOffset {
+    readonly fullWidth: number;
+    readonly fullHeight: number;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+declare class CameraProjection {
+    mode: ProjectionMode;
+    fov: number;
+    near: number;
+    far: number;
+    orthoHeight: number;
+    zoom: number;
+    width: number;
+    height: number;
+    w: number;
+    readonly world: Float64Array<ArrayBuffer>;
+    readonly view: Float64Array<ArrayBuffer>;
+    readonly projection: Float64Array<ArrayBuffer>;
+    readonly projectionInverse: Float64Array<ArrayBuffer>;
+    readonly viewProjection: Float64Array<ArrayBuffer>;
+    readonly viewProjectionInverse: Float64Array<ArrayBuffer>;
+    readonly position: Vec3;
+    private readonly offset;
+    private hasOffset;
+    private readonly custom;
+    private hasCustom;
+    private readonly scratch;
+    private readonly scratchB;
+    private readonly matrixScratch;
+    constructor(options?: CameraProjectionOptions);
+    get aspect(): number;
+    setViewport(width: number, height: number): this;
+    setPerspective(fovDegrees: number, near: number, far: number): this;
+    setOrthographic(height: number, near: number, far: number): this;
+    setViewOffset(offset: ViewOffset): this;
+    clearViewOffset(): this;
+    setCustomProjection(matrix: ArrayLike<number> | null, offset?: number): this;
+    get customProjection(): boolean;
+    updateProjection(): this;
+    update(world: ArrayLike<number>, offset?: number): this;
+    updateFromNode(source: NodeMatrixSource, node: NodeId): this;
+    updateView(): this;
+    worldToNdc(world: Vec3Like, out: Vec3): boolean;
+    inFront(world: Vec3Like): boolean;
+    worldToScreen(world: Vec3Like, out: Vec3, normalized?: boolean): boolean;
+    unproject(ndcX: number, ndcY: number, ndcZ: number, out: Vec3): Vec3;
+    screenToNdc(x: number, y: number, normalized: boolean, out: Vec3): Vec3;
+    screenToRay(x: number, y: number, out: Ray, normalized?: boolean): Ray;
+    screenToWorld(x: number, y: number, distance: number, out: Vec3, ray: Ray, normalized?: boolean): Vec3;
+    forward(out: Vec3): Vec3;
+    frustum(out: Frustum): Frustum;
+    pixelsPerUnitAt(distance: number): number;
+    private combine;
+}
+
+interface TerrainRecipe {
+    readonly base?: number;
+    readonly amplitude?: number;
+    readonly octaves?: number;
+    readonly frequency?: number;
+    readonly lacunarity?: number;
+    readonly gain?: number;
+    readonly seed?: number;
+    readonly ridged?: number;
+    readonly warp?: number;
+    readonly rockSlope?: number;
+    readonly snowHeight?: number;
+    readonly sandHeight?: number;
+}
+interface TerrainOptions {
+    readonly size?: number;
+    readonly spacing?: number;
+    readonly center?: readonly [number, number];
+    readonly heightMin?: number;
+    readonly heightRange?: number;
+    readonly tier?: DeviceTier;
+    readonly recipe?: TerrainRecipe;
+    readonly pack?: Uint8Array;
+}
+interface GrassOptions {
+    readonly seed?: number;
+    readonly density?: number;
+    readonly height?: readonly [number, number];
+    readonly width?: readonly [number, number];
+    readonly radius?: number;
+    readonly maxSlope?: number;
+    readonly layer?: number;
+    readonly color?: readonly [number, number, number];
+    readonly tipBrightness?: number;
+}
+interface LayerOptions {
+    readonly color: readonly [number, number, number];
+    readonly roughness?: number;
+    readonly tiling?: number;
+    readonly heightScale?: number;
+    readonly variation?: number;
+    readonly normalStrength?: number;
+}
+interface ScatterRules {
+    readonly area: readonly [number, number, number, number];
+    readonly seed?: number;
+    readonly kind?: number;
+    readonly spacing?: number;
+    readonly chance?: number;
+    readonly height?: readonly [number, number];
+    readonly slope?: readonly [number, number];
+    readonly scale?: readonly [number, number];
+    readonly layer?: number;
+    readonly layerFloor?: number;
+}
+declare class ScatterColumns {
+    readonly capacity: number;
+    readonly data: Float32Array;
+    readonly x: Float32Array;
+    readonly y: Float32Array;
+    readonly z: Float32Array;
+    readonly yaw: Float32Array;
+    readonly scale: Float32Array;
+    readonly kind: Uint32Array;
+    count: number;
+    constructor(capacity: number);
+}
+declare class Terrain {
+    private readonly port;
+    private readonly handle;
+    readonly radius: number;
+    private readonly eye;
+    private readonly brush;
+    private readonly grassWords;
+    private readonly layerWords;
+    private readonly rules;
+    private readonly normalOut;
+    private registerView;
+    private closed;
+    constructor(port: TerrainPort, handle: number, radius?: number);
+    gravity(surface: number): number;
+    private registers;
+    update(x: number, y: number, z: number, vx?: number, vy?: number, vz?: number): number;
+    heightAt(x: number, z: number): number;
+    normalAt(x: number, z: number, out?: Float32Array): Float32Array | null;
+    sculpt(op: BrushOp, x: number, z: number, radius: number, strength: number, target?: number, layer?: number): number;
+    paint(layer: number, x: number, z: number, radius: number, strength: number): number;
+    hole(x: number, z: number, radius: number, open?: boolean): number;
+    colliders(x: number, y: number, z: number): number;
+    grass(options?: GrassOptions | false): void;
+    setWind(x: number, z: number, strength: number, gust: number): void;
+    setInteractors(data: Float32Array, count: number): void;
+    setLayers(layers: readonly LayerOptions[]): void;
+    scatter(rules: ScatterRules, out: ScatterColumns): number;
+    get resident(): number;
+    get nodes(): number;
+    get inflight(): number;
+    get totalInstalls(): number;
+    dispose(): void;
+}
+interface PlanetOptions {
+    readonly radius: number;
+    readonly levels?: number;
+    readonly amplitude?: number;
+    readonly seed?: number;
+    readonly tier?: DeviceTier;
+}
+declare function openTerrain(port: TerrainPort | null | undefined, options?: TerrainOptions): Terrain;
+declare function openPlanet(port: TerrainPort | null | undefined, options: PlanetOptions): Terrain;
+declare function noise(port: TerrainPort | null | undefined, kind: NoiseKind, x: number, y: number, z: number, seed?: number): number;
+
+export { openTerrain as $, type PlanetOptions as A, Box3 as B, CHEMISTRY_AI_CAPABILITY as C, type DomInputOptions as D, type ProjectionMode as E, Frustum as F, type GamepadLike as G, Ray as H, type InputSurface as I, ScatterColumns as J, type ScatterRules as K, type LayerOptions as L, MAX_FORMULA as M, type NodeMatrixSource as N, Spherical as O, PROPOSAL_SCHEMA as P, type TerrainOptions as Q, type ReactionIdea as R, Sphere as S, Terrain as T, type TerrainRecipe as U, Triangle as V, attachDomInput as W, exitPointerLock as X, isPointerLocked as Y, noise as Z, openPlanet as _, CHEMISTRY_PROMPT as a, requestOrientationPermission as a0, requestPointerLock as a1, screenOrientationDegrees as a2, wheelPixels as a3, CHEMISTRY_SCHEMA as b, CHEMISTRY_TEMPLATE as c, type ChemistryAi as d, MAX_KNOWN_CHARS as e, MAX_NAME as f, MAX_SPECIES as g, MAX_TERMS as h, type Proposal as i, type ProposedMaterial as j, type ProposedTerm as k, chemistryAiSection as l, chemistryAiToml as m, knownMaterials as n, proposeReaction as o, proposalText as p, type PointerLockTarget as q, reactionRequest as r, type PointerLockDocument as s, CameraProjection as t, type CameraProjectionOptions as u, Cylindrical as v, GamepadPoller as w, type GamepadSource as x, type GrassOptions as y, Plane as z };

package/dist/testing/msw.d.mts

@@ -1,18 +1,42 @@
-import { A as AppHandle, C as CreateAppOptions } from '../server-B6dW7-Lj.mjs';
+import { HttpHandler } from 'msw';
+import { A as AppHandle, C as CreateAppOptions } from '../server-DQMWPnc8.mjs';
 import 'hono';
-import '../elements-Bty6Qs_N.mjs';
+import '../elements-DdsRig-2.mjs';
+import '../scheduling-DSRbbaZb.mjs';
 
 interface MswHandlerSetup {
-    handlers: unknown[];
+    /** Spread into `setupServer(...handlers)` or `setupWorker(...handlers)`. */
+    handlers: HttpHandler[];
     deps: AppHandle["deps"];
     baseUrl: string;
     reset: () => void;
 }
 
+/**
+ * MSW adapter — register the in-process Hono mock as MSW handlers.
+ *
+ * Use when you need MSW's request interception (e.g. component tests
+ * with React Testing Library that don't go through `createTestClient`,
+ * or browser-mode vitest). One mock, two transports.
+ *
+ *   import { setupServer } from "msw/node";
+ *   import { createMswHandlers } from "@cimplify/sdk/testing/msw";
+ *
+ *   const { handlers, deps } = await createMswHandlers({ seed: "fashion" });
+ *   const server = setupServer(...handlers);
+ *   beforeAll(() => server.listen());
+ *   afterAll(() => server.close());
+ *   afterEach(() => deps.resetAll());
+ *
+ * `msw` is an optional peer dependency — install it in your project
+ * if you want this transport. The wrapper from `@cimplify/sdk/mock/msw`
+ * is the same machinery; this is the test-time entrypoint.
+ */
+
 interface MswAdapterOptions extends CreateAppOptions {
     /** Override the base URL handlers register against. Default `http://localhost:8787`. */
     baseUrl?: string;
 }
 declare function createMswHandlers(options?: MswAdapterOptions): Promise<MswHandlerSetup>;
 
-export { type MswAdapterOptions, createMswHandlers };
+export { type MswAdapterOptions, type MswHandlerSetup, createMswHandlers };

package/dist/testing/msw.d.ts

@@ -1,18 +1,42 @@
-import { A as AppHandle, C as CreateAppOptions } from '../server-Dckg4Vdr.js';
+import { HttpHandler } from 'msw';
+import { A as AppHandle, C as CreateAppOptions } from '../server-D29IIuDV.js';
 import 'hono';
-import '../elements-Bty6Qs_N.js';
+import '../elements-DdsRig-2.js';
+import '../scheduling-D2ajXpMC.js';
 
 interface MswHandlerSetup {
-    handlers: unknown[];
+    /** Spread into `setupServer(...handlers)` or `setupWorker(...handlers)`. */
+    handlers: HttpHandler[];
     deps: AppHandle["deps"];
     baseUrl: string;
     reset: () => void;
 }
 
+/**
+ * MSW adapter — register the in-process Hono mock as MSW handlers.
+ *
+ * Use when you need MSW's request interception (e.g. component tests
+ * with React Testing Library that don't go through `createTestClient`,
+ * or browser-mode vitest). One mock, two transports.
+ *
+ *   import { setupServer } from "msw/node";
+ *   import { createMswHandlers } from "@cimplify/sdk/testing/msw";
+ *
+ *   const { handlers, deps } = await createMswHandlers({ seed: "fashion" });
+ *   const server = setupServer(...handlers);
+ *   beforeAll(() => server.listen());
+ *   afterAll(() => server.close());
+ *   afterEach(() => deps.resetAll());
+ *
+ * `msw` is an optional peer dependency — install it in your project
+ * if you want this transport. The wrapper from `@cimplify/sdk/mock/msw`
+ * is the same machinery; this is the test-time entrypoint.
+ */
+
 interface MswAdapterOptions extends CreateAppOptions {
     /** Override the base URL handlers register against. Default `http://localhost:8787`. */
     baseUrl?: string;
 }
 declare function createMswHandlers(options?: MswAdapterOptions): Promise<MswHandlerSetup>;
 
-export { type MswAdapterOptions, createMswHandlers };
+export { type MswAdapterOptions, type MswHandlerSetup, createMswHandlers };

package/dist/testing/msw.js

@@ -1,36 +1,30 @@
 'use strict';
 
-var chunkUVRPC2P7_js = require('../chunk-UVRPC2P7.js');
-require('../chunk-XREIZ56K.js');
-require('../chunk-EV2EVOYS.js');
-require('../chunk-ANT574FD.js');
-require('../chunk-OWW5GUSB.js');
+var chunkSNNEOS5Z_js = require('../chunk-SNNEOS5Z.js');
+require('../chunk-AWPV33OO.js');
+require('../chunk-WOF3AD3J.js');
+require('../chunk-GTJWQAGU.js');
+require('../chunk-UCR5HRYM.js');
+require('../chunk-JGBCIKJV.js');
 
 // src/mock/msw.ts
 async function createMswHandlers(options = {}) {
-  const baseUrl = options.baseUrl ?? "http://localhost:8787";
-  const handle = chunkUVRPC2P7_js.createMockApp(options);
-  const msw = await import('msw').catch(() => {
+  let baseUrl = options.baseUrl ?? "http://localhost:8787", handle = chunkSNNEOS5Z_js.createMockApp(options), msw = await import('msw').catch(() => {
     throw new Error("msw is required to use @cimplify/sdk/mock/msw \u2014 install it as a peer dependency");
-  });
-  const proxy = async ({ request }) => {
-    const url = new URL(request.url);
-    const path = url.pathname + url.search;
-    const init = {
+  }), proxy = async ({ request }) => {
+    let url = new URL(request.url), path = url.pathname + url.search, init = {
       method: request.method,
       headers: request.headers,
       body: ["GET", "HEAD"].includes(request.method) ? void 0 : await request.text()
     };
     return handle.request(path, init);
-  };
-  const apiBase = baseUrl.replace(/\/$/, "");
-  const handlers = [
-    msw.http.all(`${apiBase}/api/v1/*`, proxy),
-    msw.http.all(`${apiBase}/_mock/*`, proxy),
-    msw.http.get(`${apiBase}/healthz`, proxy)
-  ];
+  }, apiBase = baseUrl.replace(/\/$/, "");
   return {
-    handlers,
+    handlers: [
+      msw.http.all(`${apiBase}/api/v1/*`, proxy),
+      msw.http.all(`${apiBase}/_mock/*`, proxy),
+      msw.http.get(`${apiBase}/healthz`, proxy)
+    ],
     deps: handle.deps,
     baseUrl,
     reset: () => handle.deps.resetAll()

package/dist/testing/msw.mjs

@@ -1,34 +1,28 @@
-import { createMockApp } from '../chunk-XBL3TMPC.mjs';
-import '../chunk-U4MW6PYU.mjs';
-import '../chunk-33VCYWVL.mjs';
-import '../chunk-KG3WT4PR.mjs';
-import '../chunk-3G6RQLXK.mjs';
+import { createMockApp } from '../chunk-IZDWAL53.mjs';
+import '../chunk-76L2V6KD.mjs';
+import '../chunk-SWX4SALA.mjs';
+import '../chunk-E6QQKDNE.mjs';
+import '../chunk-GCKWKLZF.mjs';
+import '../chunk-25T4JHEA.mjs';
 
 // src/mock/msw.ts
 async function createMswHandlers(options = {}) {
-  const baseUrl = options.baseUrl ?? "http://localhost:8787";
-  const handle = createMockApp(options);
-  const msw = await import('msw').catch(() => {
+  let baseUrl = options.baseUrl ?? "http://localhost:8787", handle = createMockApp(options), msw = await import('msw').catch(() => {
     throw new Error("msw is required to use @cimplify/sdk/mock/msw \u2014 install it as a peer dependency");
-  });
-  const proxy = async ({ request }) => {
-    const url = new URL(request.url);
-    const path = url.pathname + url.search;
-    const init = {
+  }), proxy = async ({ request }) => {
+    let url = new URL(request.url), path = url.pathname + url.search, init = {
       method: request.method,
       headers: request.headers,
       body: ["GET", "HEAD"].includes(request.method) ? void 0 : await request.text()
     };
     return handle.request(path, init);
-  };
-  const apiBase = baseUrl.replace(/\/$/, "");
-  const handlers = [
-    msw.http.all(`${apiBase}/api/v1/*`, proxy),
-    msw.http.all(`${apiBase}/_mock/*`, proxy),
-    msw.http.get(`${apiBase}/healthz`, proxy)
-  ];
+  }, apiBase = baseUrl.replace(/\/$/, "");
   return {
-    handlers,
+    handlers: [
+      msw.http.all(`${apiBase}/api/v1/*`, proxy),
+      msw.http.all(`${apiBase}/_mock/*`, proxy),
+      msw.http.get(`${apiBase}/healthz`, proxy)
+    ],
     deps: handle.deps,
     baseUrl,
     reset: () => handle.deps.resetAll()

package/dist/testing/suite.d.mts

@@ -1,9 +1,10 @@
 import { TestAPI } from 'vitest';
-import { T as TestClientHandle } from '../client-BSP9U1O1.mjs';
-import { C as CreateAppOptions } from '../server-B6dW7-Lj.mjs';
-export { S as SeedName } from '../server-B6dW7-Lj.mjs';
-import '../catalogue-OT89_Ifs.mjs';
-import '../elements-Bty6Qs_N.mjs';
+import { T as TestClientHandle } from '../client-CX_WR0-J.mjs';
+import { C as CreateAppOptions } from '../server-DQMWPnc8.mjs';
+export { S as SeedName } from '../server-DQMWPnc8.mjs';
+import '../catalogue-CPTMyBUz.mjs';
+import '../elements-DdsRig-2.mjs';
+import '../scheduling-DSRbbaZb.mjs';
 import 'hono';
 
 /**

package/dist/testing/suite.d.ts

@@ -1,9 +1,10 @@
 import { TestAPI } from 'vitest';
-import { T as TestClientHandle } from '../client-B878xeAP.js';
-import { C as CreateAppOptions } from '../server-Dckg4Vdr.js';
-export { S as SeedName } from '../server-Dckg4Vdr.js';
-import '../catalogue-B4eLL8Mi.js';
-import '../elements-Bty6Qs_N.js';
+import { T as TestClientHandle } from '../client-dqOhP9Nc.js';
+import { C as CreateAppOptions } from '../server-D29IIuDV.js';
+export { S as SeedName } from '../server-D29IIuDV.js';
+import '../catalogue-OTuS5zp-.js';
+import '../elements-DdsRig-2.js';
+import '../scheduling-D2ajXpMC.js';
 import 'hono';
 
 /**