@valbuild/next 0.106.1 → 0.108.0

package/dist/{ValCanvasBridge-d8713d9d.esm.js → ValCanvasBridge-1310aaeb.esm.js}

@@ -327,6 +327,130 @@ function ValCanvasBridge(_ref) {
     };
   }, [post]);
 
+  /**
+   * Two-finger gestures, handed to the studio.
+   *
+   * The window around the page is the studio's, and the page is a frame: a
+   * finger that lands here is this document's and the studio never hears about
+   * it. So a pinch on the page could not zoom the window, which on a phone is
+   * the only zoom there is — the toolbar's + and - are a poor substitute for the
+   * gesture everyone already makes.
+   *
+   * Two fingers and only two. One finger is the page's: it scrolls it, taps its
+   * links, drags whatever the page put there. Two are the window's, for zooming
+   * and for moving the page around inside it. Nothing has to be moded, and the
+   * two cannot be confused for one another.
+   *
+   * `passive: false` because both handlers cancel: the default for two fingers
+   * is the browser's own page zoom, which inside a frame the studio is already
+   * scaling produces two zooms fighting over one gesture.
+   */
+  React.useEffect(function () {
+    var midpoint = function midpoint(touches) {
+      return {
+        x: (touches[0].clientX + touches[1].clientX) / 2,
+        y: (touches[0].clientY + touches[1].clientY) / 2
+      };
+    };
+    var span = function span(touches) {
+      return Math.hypot(touches[0].clientX - touches[1].clientX, touches[0].clientY - touches[1].clientY);
+    };
+    /**
+     * Whether a gesture is in progress.
+     *
+     * `touchend` fires per finger, so lifting one of two leaves a `touchend`
+     * carrying a single touch — which is the end of the gesture — and the
+     * second leaves one carrying none. Without this the second would post a
+     * second `end` for a gesture that was already over.
+     */
+    var active = false;
+    var onStart = function onStart(event) {
+      if (event.touches.length !== 2) return;
+      event.preventDefault();
+      active = true;
+      post({
+        val: VAL_CANVAS_MESSAGE,
+        type: "pinch",
+        phase: "start",
+        span: span(event.touches),
+        center: midpoint(event.touches)
+      });
+    };
+    var onMove = function onMove(event) {
+      if (event.touches.length !== 2 || !active) return;
+      event.preventDefault();
+      post({
+        val: VAL_CANVAS_MESSAGE,
+        type: "pinch",
+        phase: "move",
+        span: span(event.touches),
+        center: midpoint(event.touches)
+      });
+    };
+    var onEnd = function onEnd(event) {
+      if (!active || event.touches.length >= 2) return;
+      active = false;
+      post({
+        val: VAL_CANVAS_MESSAGE,
+        type: "pinch",
+        phase: "end",
+        span: 0,
+        center: {
+          x: 0,
+          y: 0
+        }
+      });
+    };
+    document.addEventListener("touchstart", onStart, {
+      passive: false
+    });
+    document.addEventListener("touchmove", onMove, {
+      passive: false
+    });
+    document.addEventListener("touchend", onEnd);
+    document.addEventListener("touchcancel", onEnd);
+    return function () {
+      document.removeEventListener("touchstart", onStart);
+      document.removeEventListener("touchmove", onMove);
+      document.removeEventListener("touchend", onEnd);
+      document.removeEventListener("touchcancel", onEnd);
+    };
+  }, [post]);
+
+  /**
+   * And ctrl/cmd + wheel, which is what a trackpad pinch reports as.
+   *
+   * The same problem as touches and the same answer: the wheel event lands on
+   * this document, so without relaying it a trackpad pinch over the page does
+   * nothing while the identical gesture over the canvas background zooms.
+   *
+   * A PLAIN wheel is deliberately left alone — that is the page scrolling
+   * itself, which is exactly what it should do.
+   */
+  React.useEffect(function () {
+    var onWheel = function onWheel(event) {
+      if (!event.ctrlKey && !event.metaKey) return;
+      event.preventDefault();
+      post({
+        val: VAL_CANVAS_MESSAGE,
+        type: "zoom",
+        // The same response curve the studio uses for a wheel on its own
+        // background, so the gesture feels the same on both sides of the frame.
+        factor: 1 - event.deltaY / 300,
+        center: {
+          x: event.clientX,
+          y: event.clientY
+        }
+      });
+    };
+    document.addEventListener("wheel", onWheel, {
+      passive: false
+    });
+    return function () {
+      return document.removeEventListener("wheel", onWheel);
+    };
+  }, [post]);
+
   /**
    * The outlines, as a stylesheet rather than as injected elements.
    *

package/dist/ValCanvasBridge-32299c6e.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./ValCanvasBridge-32299c6e.cjs.prod.js");
+} else {
+  module.exports = require("./ValCanvasBridge-32299c6e.cjs.dev.js");
+}

package/dist/{ValCanvasBridge-f75509c6.cjs.prod.js → ValCanvasBridge-32299c6e.cjs.prod.js}

@@ -335,6 +335,130 @@ function ValCanvasBridge(_ref) {
     };
   }, [post]);
 
+  /**
+   * Two-finger gestures, handed to the studio.
+   *
+   * The window around the page is the studio's, and the page is a frame: a
+   * finger that lands here is this document's and the studio never hears about
+   * it. So a pinch on the page could not zoom the window, which on a phone is
+   * the only zoom there is — the toolbar's + and - are a poor substitute for the
+   * gesture everyone already makes.
+   *
+   * Two fingers and only two. One finger is the page's: it scrolls it, taps its
+   * links, drags whatever the page put there. Two are the window's, for zooming
+   * and for moving the page around inside it. Nothing has to be moded, and the
+   * two cannot be confused for one another.
+   *
+   * `passive: false` because both handlers cancel: the default for two fingers
+   * is the browser's own page zoom, which inside a frame the studio is already
+   * scaling produces two zooms fighting over one gesture.
+   */
+  React__default["default"].useEffect(function () {
+    var midpoint = function midpoint(touches) {
+      return {
+        x: (touches[0].clientX + touches[1].clientX) / 2,
+        y: (touches[0].clientY + touches[1].clientY) / 2
+      };
+    };
+    var span = function span(touches) {
+      return Math.hypot(touches[0].clientX - touches[1].clientX, touches[0].clientY - touches[1].clientY);
+    };
+    /**
+     * Whether a gesture is in progress.
+     *
+     * `touchend` fires per finger, so lifting one of two leaves a `touchend`
+     * carrying a single touch — which is the end of the gesture — and the
+     * second leaves one carrying none. Without this the second would post a
+     * second `end` for a gesture that was already over.
+     */
+    var active = false;
+    var onStart = function onStart(event) {
+      if (event.touches.length !== 2) return;
+      event.preventDefault();
+      active = true;
+      post({
+        val: internal.VAL_CANVAS_MESSAGE,
+        type: "pinch",
+        phase: "start",
+        span: span(event.touches),
+        center: midpoint(event.touches)
+      });
+    };
+    var onMove = function onMove(event) {
+      if (event.touches.length !== 2 || !active) return;
+      event.preventDefault();
+      post({
+        val: internal.VAL_CANVAS_MESSAGE,
+        type: "pinch",
+        phase: "move",
+        span: span(event.touches),
+        center: midpoint(event.touches)
+      });
+    };
+    var onEnd = function onEnd(event) {
+      if (!active || event.touches.length >= 2) return;
+      active = false;
+      post({
+        val: internal.VAL_CANVAS_MESSAGE,
+        type: "pinch",
+        phase: "end",
+        span: 0,
+        center: {
+          x: 0,
+          y: 0
+        }
+      });
+    };
+    document.addEventListener("touchstart", onStart, {
+      passive: false
+    });
+    document.addEventListener("touchmove", onMove, {
+      passive: false
+    });
+    document.addEventListener("touchend", onEnd);
+    document.addEventListener("touchcancel", onEnd);
+    return function () {
+      document.removeEventListener("touchstart", onStart);
+      document.removeEventListener("touchmove", onMove);
+      document.removeEventListener("touchend", onEnd);
+      document.removeEventListener("touchcancel", onEnd);
+    };
+  }, [post]);
+
+  /**
+   * And ctrl/cmd + wheel, which is what a trackpad pinch reports as.
+   *
+   * The same problem as touches and the same answer: the wheel event lands on
+   * this document, so without relaying it a trackpad pinch over the page does
+   * nothing while the identical gesture over the canvas background zooms.
+   *
+   * A PLAIN wheel is deliberately left alone — that is the page scrolling
+   * itself, which is exactly what it should do.
+   */
+  React__default["default"].useEffect(function () {
+    var onWheel = function onWheel(event) {
+      if (!event.ctrlKey && !event.metaKey) return;
+      event.preventDefault();
+      post({
+        val: internal.VAL_CANVAS_MESSAGE,
+        type: "zoom",
+        // The same response curve the studio uses for a wheel on its own
+        // background, so the gesture feels the same on both sides of the frame.
+        factor: 1 - event.deltaY / 300,
+        center: {
+          x: event.clientX,
+          y: event.clientY
+        }
+      });
+    };
+    document.addEventListener("wheel", onWheel, {
+      passive: false
+    });
+    return function () {
+      return document.removeEventListener("wheel", onWheel);
+    };
+  }, [post]);
+
   /**
    * The outlines, as a stylesheet rather than as injected elements.
    *

package/dist/{ValCanvasBridge-96f67a41.cjs.dev.js → ValCanvasBridge-cb2d9112.cjs.dev.js}

@@ -335,6 +335,130 @@ function ValCanvasBridge(_ref) {
     };
   }, [post]);
 
+  /**
+   * Two-finger gestures, handed to the studio.
+   *
+   * The window around the page is the studio's, and the page is a frame: a
+   * finger that lands here is this document's and the studio never hears about
+   * it. So a pinch on the page could not zoom the window, which on a phone is
+   * the only zoom there is — the toolbar's + and - are a poor substitute for the
+   * gesture everyone already makes.
+   *
+   * Two fingers and only two. One finger is the page's: it scrolls it, taps its
+   * links, drags whatever the page put there. Two are the window's, for zooming
+   * and for moving the page around inside it. Nothing has to be moded, and the
+   * two cannot be confused for one another.
+   *
+   * `passive: false` because both handlers cancel: the default for two fingers
+   * is the browser's own page zoom, which inside a frame the studio is already
+   * scaling produces two zooms fighting over one gesture.
+   */
+  React__default["default"].useEffect(function () {
+    var midpoint = function midpoint(touches) {
+      return {
+        x: (touches[0].clientX + touches[1].clientX) / 2,
+        y: (touches[0].clientY + touches[1].clientY) / 2
+      };
+    };
+    var span = function span(touches) {
+      return Math.hypot(touches[0].clientX - touches[1].clientX, touches[0].clientY - touches[1].clientY);
+    };
+    /**
+     * Whether a gesture is in progress.
+     *
+     * `touchend` fires per finger, so lifting one of two leaves a `touchend`
+     * carrying a single touch — which is the end of the gesture — and the
+     * second leaves one carrying none. Without this the second would post a
+     * second `end` for a gesture that was already over.
+     */
+    var active = false;
+    var onStart = function onStart(event) {
+      if (event.touches.length !== 2) return;
+      event.preventDefault();
+      active = true;
+      post({
+        val: internal.VAL_CANVAS_MESSAGE,
+        type: "pinch",
+        phase: "start",
+        span: span(event.touches),
+        center: midpoint(event.touches)
+      });
+    };
+    var onMove = function onMove(event) {
+      if (event.touches.length !== 2 || !active) return;
+      event.preventDefault();
+      post({
+        val: internal.VAL_CANVAS_MESSAGE,
+        type: "pinch",
+        phase: "move",
+        span: span(event.touches),
+        center: midpoint(event.touches)
+      });
+    };
+    var onEnd = function onEnd(event) {
+      if (!active || event.touches.length >= 2) return;
+      active = false;
+      post({
+        val: internal.VAL_CANVAS_MESSAGE,
+        type: "pinch",
+        phase: "end",
+        span: 0,
+        center: {
+          x: 0,
+          y: 0
+        }
+      });
+    };
+    document.addEventListener("touchstart", onStart, {
+      passive: false
+    });
+    document.addEventListener("touchmove", onMove, {
+      passive: false
+    });
+    document.addEventListener("touchend", onEnd);
+    document.addEventListener("touchcancel", onEnd);
+    return function () {
+      document.removeEventListener("touchstart", onStart);
+      document.removeEventListener("touchmove", onMove);
+      document.removeEventListener("touchend", onEnd);
+      document.removeEventListener("touchcancel", onEnd);
+    };
+  }, [post]);
+
+  /**
+   * And ctrl/cmd + wheel, which is what a trackpad pinch reports as.
+   *
+   * The same problem as touches and the same answer: the wheel event lands on
+   * this document, so without relaying it a trackpad pinch over the page does
+   * nothing while the identical gesture over the canvas background zooms.
+   *
+   * A PLAIN wheel is deliberately left alone — that is the page scrolling
+   * itself, which is exactly what it should do.
+   */
+  React__default["default"].useEffect(function () {
+    var onWheel = function onWheel(event) {
+      if (!event.ctrlKey && !event.metaKey) return;
+      event.preventDefault();
+      post({
+        val: internal.VAL_CANVAS_MESSAGE,
+        type: "zoom",
+        // The same response curve the studio uses for a wheel on its own
+        // background, so the gesture feels the same on both sides of the frame.
+        factor: 1 - event.deltaY / 300,
+        center: {
+          x: event.clientX,
+          y: event.clientY
+        }
+      });
+    };
+    document.addEventListener("wheel", onWheel, {
+      passive: false
+    });
+    return function () {
+      return document.removeEventListener("wheel", onWheel);
+    };
+  }, [post]);
+
   /**
    * The outlines, as a stylesheet rather than as injected elements.
    *

package/dist/ValNextProvider-3209948c.esm.js

@@ -11,7 +11,7 @@ import { SET_AUTO_TAG_JSX_ENABLED } from '@valbuild/react/stega';
 import { VAL_THEME_SESSION_STORAGE_KEY, createValClient, isValCanvasFrame } from '@valbuild/shared/internal';
 import { p as prefixStyles, u as useConfigStorageSave, f as floatDarkBg, d as floatLightBg, v as valPrefixedClass, c as cn } from './fallbackColors-5ead2c26.esm.js';
 import { _ as _createForOfIteratorHelper } from './createForOfIteratorHelper-5758a730.esm.js';
-import { ValCanvasBridge } from './ValCanvasBridge-d8713d9d.esm.js';
+import { ValCanvasBridge } from './ValCanvasBridge-1310aaeb.esm.js';
 import { jsxs, jsx } from 'react/jsx-runtime';
 import './unsupportedIterableToArray-5baabfdc.esm.js';
 import './defineProperty-cca5affa.esm.js';

package/dist/ValNextProvider-3d8ebfec.cjs.dev.js

@@ -15,7 +15,7 @@ var stega = require('@valbuild/react/stega');
 var internal = require('@valbuild/shared/internal');
 var fallbackColors = require('./fallbackColors-9a2ac53a.cjs.dev.js');
 var createForOfIteratorHelper = require('./createForOfIteratorHelper-0445603c.cjs.dev.js');
-var ValCanvasBridge = require('./ValCanvasBridge-96f67a41.cjs.dev.js');
+var ValCanvasBridge = require('./ValCanvasBridge-cb2d9112.cjs.dev.js');
 var jsxRuntime = require('react/jsx-runtime');
 require('./unsupportedIterableToArray-c8ab77c9.cjs.dev.js');
 require('./defineProperty-f90345d7.cjs.dev.js');

package/dist/ValNextProvider-3fdf8756.cjs.prod.js

@@ -15,7 +15,7 @@ var stega = require('@valbuild/react/stega');
 var internal = require('@valbuild/shared/internal');
 var fallbackColors = require('./fallbackColors-d4a5b0da.cjs.prod.js');
 var createForOfIteratorHelper = require('./createForOfIteratorHelper-d4afcad8.cjs.prod.js');
-var ValCanvasBridge = require('./ValCanvasBridge-f75509c6.cjs.prod.js');
+var ValCanvasBridge = require('./ValCanvasBridge-32299c6e.cjs.prod.js');
 var jsxRuntime = require('react/jsx-runtime');
 require('./unsupportedIterableToArray-0d2087a2.cjs.prod.js');
 require('./defineProperty-8951f469.cjs.prod.js');

package/dist/declarations/src/external_exempt_from_val_quickjs.d.ts

@@ -18,100 +18,24 @@ export { ValProvider } from "./ValProvider.js";
 export { ValImage, type ValImageProps } from "./ValImage.js";
 export { ValApp } from "./ValApp.js";
 export { ValModulesClient, useRegisterValModules } from "./ValModulesClient.js";
+import { Internal as InternalCore } from "@valbuild/core";
+import { VERSION } from "./version.js";
 export type * as t from "./ValTypes.js";
 export type { DecodeVal } from "@valbuild/react/stega";
-export declare const Internal: {
-    VERSION: {
-        next: string | null;
-        core: string | null;
+/**
+ * Annotated rather than inferred.
+ *
+ * The inferred type of the spread below reaches into @valbuild/core's internal
+ * declaration files for names like `NonEmptyArray` and `createValPathOfItem`,
+ * which the declaration emitter cannot write down portably: `preconstruct
+ * build` fails with a wall of TS2883 "the inferred type of 'Internal' cannot be
+ * named without a reference to ..." while `tsc --noEmit` stays happy, so it only
+ * shows up in the build job. Naming the type in terms of `typeof InternalCore`
+ * keeps everything the emitter needs reachable through the package entry point.
+ */
+type InternalWithNextVersion = Omit<typeof InternalCore, "VERSION"> & {
+    VERSION: typeof InternalCore.VERSION & {
+        next: typeof VERSION;
     };
-    mediaUrl: typeof import("@valbuild/core/dist/declarations/src/source/media").mediaUrl;
-    resolveMedia: typeof import("@valbuild/core/dist/declarations/src/source/media").resolveMedia;
-    isRemoteMediaPath: typeof import("@valbuild/core/dist/declarations/src/source/media").isRemoteMediaPath;
-    media: {
-        fillFromGallery: typeof import("@valbuild/core/dist/declarations/src/source/media").fillFromGallery;
-    };
-    getSchema: typeof import("@valbuild/core/dist/declarations/src/selector").getSchema;
-    getValPath: typeof import("@valbuild/core/dist/declarations/src/val").getValPath;
-    getSource: typeof import("@valbuild/core/dist/declarations/src/module").getSource;
-    isValModule: typeof import("@valbuild/core/dist/declarations/src/module").isValModule;
-    resolvePath: typeof import("@valbuild/core/dist/declarations/src/module").resolvePath;
-    safeResolvePath: typeof import("@valbuild/core/dist/declarations/src/module").safeResolvePath;
-    splitModuleFilePathAndModulePath: typeof import("@valbuild/core/dist/declarations/src/module").splitModuleFilePathAndModulePath;
-    joinModuleFilePathAndModulePath: typeof import("@valbuild/core/dist/declarations/src/module").joinModuleFilePathAndModulePath;
-    nextAppRouter: import("@valbuild/core").ValRouter;
-    externalPageRouter: import("@valbuild/core").ValRouter;
-    color: {
-        parseColor: typeof import("@valbuild/core/dist/declarations/src/schema/colorFormat").parseColor;
-        formatColor: typeof import("@valbuild/core/dist/declarations/src/schema/colorFormat").formatColor;
-        convertColor: typeof import("@valbuild/core/dist/declarations/src/schema/colorFormat").convertColor;
-        detectColorFormat: typeof import("@valbuild/core/dist/declarations/src/schema/colorFormat").detectColorFormat;
-        colorToHex: typeof import("@valbuild/core/dist/declarations/src/schema/colorFormat").colorToHex;
-    };
-    remote: {
-        createRemoteRef: typeof import("@valbuild/core/dist/declarations/src/source/remote").createRemoteRef;
-        getValidationBasis: typeof import("@valbuild/core/dist/declarations/src/remote/validationBasis").getValidationBasis;
-        getValidationHash: typeof import("@valbuild/core/dist/declarations/src/remote/validationBasis").getValidationHash;
-        getFileHash: typeof import("@valbuild/core/dist/declarations/src/remote/fileHash").getFileHash;
-        hashToRemoteFileHash: typeof import("@valbuild/core/dist/declarations/src/remote/fileHash").hashToRemoteFileHash;
-        splitRemoteRef: typeof import("@valbuild/core/dist/declarations/src/remote/splitRemoteRef").splitRemoteRef;
-    };
-    validate: (val: import("@valbuild/core").ValModule<import("@valbuild/core").SelectorSource>, path: import("@valbuild/core").SourcePath, src: unknown) => import("@valbuild/core").ValidationErrors | undefined;
-    isVal: typeof import("@valbuild/core/dist/declarations/src/val").isVal;
-    isJson: typeof import("@valbuild/core/dist/declarations/src/source/json").isJson;
-    getJsonImport: typeof import("@valbuild/core/dist/declarations/src/source/json").getJsonImport;
-    resolveJsonValues: typeof import("@valbuild/core/dist/declarations/src/source/json").resolveJsonValues;
-    createValPathOfItem: typeof import("@valbuild/core/dist/declarations/src/selector/SelectorProxy").createValPathOfItem;
-    getSHA256Hash: (bits: Uint8Array) => string;
-    initSchema: typeof import("@valbuild/core/dist/declarations/src/initSchema").initSchema;
-    getMimeType: typeof import("@valbuild/core/dist/declarations/src/mimeType").getMimeType;
-    mimeTypeToFileExt: typeof import("@valbuild/core/dist/declarations/src/mimeType").mimeTypeToFileExt;
-    filenameToMimeType: typeof import("@valbuild/core/dist/declarations/src/mimeType").filenameToMimeType;
-    EXT_TO_MIME_TYPES: Record<string, string>;
-    MIME_TYPES_TO_EXT: {
-        [k: string]: string;
-    };
-    ModuleFilePathSep: string;
-    notFileOp: (op: import("@valbuild/core/patch").Operation) => op is {
-        op: "add";
-        path: string[];
-        value: import("@valbuild/core/patch").JSONValue;
-    } | {
-        op: "remove";
-        path: import("@valbuild/core/dist/declarations/src/fp/array").NonEmptyArray<string>;
-    } | {
-        op: "replace";
-        path: string[];
-        value: import("@valbuild/core/patch").JSONValue;
-    } | {
-        op: "move";
-        from: import("@valbuild/core/dist/declarations/src/fp/array").NonEmptyArray<string>;
-        path: string[];
-    } | {
-        op: "copy";
-        from: string[];
-        path: string[];
-    } | {
-        op: "test";
-        path: string[];
-        value: import("@valbuild/core/patch").JSONValue;
-    };
-    isFileOp: (op: import("@valbuild/core/patch").Operation) => op is {
-        op: "file";
-        path: string[];
-        filePath: string;
-        value: string;
-        remote: boolean;
-    };
-    createPatchJSONPath: (modulePath: import("@valbuild/core").ModulePath) => string;
-    createPatchPath: (modulePath: import("@valbuild/core").ModulePath) => string[];
-    splitModulePath: typeof import("@valbuild/core/dist/declarations/src/module").splitModulePath;
-    splitModuleFilePath: typeof import("@valbuild/core/dist/declarations/src/module").splitModuleFilePath;
-    splitJoinedSourcePaths: typeof import("@valbuild/core/dist/declarations/src/module").splitJoinedSourcePaths;
-    parentOfSourcePath: typeof import("@valbuild/core/dist/declarations/src/module").parentOfSourcePath;
-    patchPathToModulePath: typeof import("@valbuild/core/dist/declarations/src/module").patchPathToModulePath;
-    VAL_ENABLE_COOKIE_NAME: "val_enable";
-    VAL_STATE_COOKIE: "val_state";
-    VAL_SESSION_COOKIE: "val_session";
-    createFilename: (data: string | null, filename: string | null, metadata: import("@valbuild/core").FileMetadata | import("@valbuild/core").ImageMetadata | undefined, sha256: string) => string | null;
 };
+export declare const Internal: InternalWithNextVersion;

package/dist/declarations/src/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION: string | null;

package/dist/valbuild-next.cjs.dev.js

@@ -198,6 +198,18 @@ stega.autoTagJSX();
 
 // Convenience types
 
+/**
+ * Annotated rather than inferred.
+ *
+ * The inferred type of the spread below reaches into @valbuild/core's internal
+ * declaration files for names like `NonEmptyArray` and `createValPathOfItem`,
+ * which the declaration emitter cannot write down portably: `preconstruct
+ * build` fails with a wall of TS2883 "the inferred type of 'Internal' cannot be
+ * named without a reference to ..." while `tsc --noEmit` stays happy, so it only
+ * shows up in the build job. Naming the type in terms of `typeof InternalCore`
+ * keeps everything the emitter needs reachable through the package entry point.
+ */
+
 var Internal = objectSpread2._objectSpread2(objectSpread2._objectSpread2({}, core.Internal), {}, {
   VERSION: objectSpread2._objectSpread2(objectSpread2._objectSpread2({}, core.Internal.VERSION), {}, {
     next: version.VERSION

package/dist/valbuild-next.cjs.prod.js

@@ -198,6 +198,18 @@ stega.autoTagJSX();
 
 // Convenience types
 
+/**
+ * Annotated rather than inferred.
+ *
+ * The inferred type of the spread below reaches into @valbuild/core's internal
+ * declaration files for names like `NonEmptyArray` and `createValPathOfItem`,
+ * which the declaration emitter cannot write down portably: `preconstruct
+ * build` fails with a wall of TS2883 "the inferred type of 'Internal' cannot be
+ * named without a reference to ..." while `tsc --noEmit` stays happy, so it only
+ * shows up in the build job. Naming the type in terms of `typeof InternalCore`
+ * keeps everything the emitter needs reachable through the package entry point.
+ */
+
 var Internal = objectSpread2._objectSpread2(objectSpread2._objectSpread2({}, core.Internal), {}, {
   VERSION: objectSpread2._objectSpread2(objectSpread2._objectSpread2({}, core.Internal.VERSION), {}, {
     next: version.VERSION

package/dist/valbuild-next.esm.js

@@ -174,6 +174,18 @@ autoTagJSX();
 
 // Convenience types
 
+/**
+ * Annotated rather than inferred.
+ *
+ * The inferred type of the spread below reaches into @valbuild/core's internal
+ * declaration files for names like `NonEmptyArray` and `createValPathOfItem`,
+ * which the declaration emitter cannot write down portably: `preconstruct
+ * build` fails with a wall of TS2883 "the inferred type of 'Internal' cannot be
+ * named without a reference to ..." while `tsc --noEmit` stays happy, so it only
+ * shows up in the build job. Naming the type in terms of `typeof InternalCore`
+ * keeps everything the emitter needs reachable through the package entry point.
+ */
+
 var Internal = _objectSpread2(_objectSpread2({}, Internal$1), {}, {
   VERSION: _objectSpread2(_objectSpread2({}, Internal$1.VERSION), {}, {
     next: VERSION

package/package.json

@@ -12,7 +12,7 @@
     "next",
     "react"
   ],
-  "version": "0.106.1",
+  "version": "0.108.0",
   "main": "dist/valbuild-next.cjs.js",
   "module": "dist/valbuild-next.esm.js",
   "exports": {
@@ -48,21 +48,21 @@
     "client-only": "^0.0.1",
     "server-only": "^0.0.1",
     "@valbuild/core": "0.106.0",
-    "@valbuild/language-server": "0.106.1",
-    "@valbuild/react": "0.106.1",
-    "@valbuild/server": "0.106.1",
-    "@valbuild/shared": "0.106.0",
-    "@valbuild/ui": "0.106.1"
+    "@valbuild/react": "0.108.0",
+    "@valbuild/language-server": "0.108.0",
+    "@valbuild/server": "0.108.0",
+    "@valbuild/shared": "0.108.0",
+    "@valbuild/ui": "0.108.0"
   },
   "devDependencies": {
-    "@testing-library/react": "^16.3.2",
+    "@testing-library/react": "^16.3.3",
     "@types/react": "^19.2.18",
     "@types/react-dom": "^19.2.5",
-    "jest-environment-jsdom": "^29.5.0",
+    "jest-environment-jsdom": "^30.5.0",
     "next": "^16.3.3",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.3"
   },
   "peerDependencies": {
     "next": ">=14.3.0",

package/dist/ValCanvasBridge-f75509c6.cjs.js

@@ -1,7 +0,0 @@
-'use strict';
-
-if (process.env.NODE_ENV === "production") {
-  module.exports = require("./ValCanvasBridge-f75509c6.cjs.prod.js");
-} else {
-  module.exports = require("./ValCanvasBridge-f75509c6.cjs.dev.js");
-}