@field/cascade 0.8.0 → 0.11.0

package/dist/contracts/validate.js

@@ -19,9 +19,9 @@ export const CAPABILITIES_BY_ENVIRONMENT = {
 };
 const ALLOWED = CAPABILITIES_BY_ENVIRONMENT;
 const fields = (names) => new Set(names.split(" "));
-const TOP_FIELDS = fields("apiVersion runsOn container capabilities label description icon inputs outputs props");
-const DATA_FIELDS = fields("kind type default description variadic min max step accept control options");
-const OUTPUT_FIELDS = fields("kind type description");
+const TOP_FIELDS = fields("apiVersion runsOn container capabilities source label description icon inputs outputs props");
+const DATA_FIELDS = fields("kind type default description variadic min max step accept control options schema fields");
+const OUTPUT_FIELDS = fields("kind type description schema fields");
 const PROP_FIELDS = fields("type default label description min max step accept control options expression action");
 function diagnostic(code, message, path) {
     return { phase: "definition", code: `definition/${code}`, message, path };
@@ -94,6 +94,8 @@ export function validateNodeDefinition(value) {
         value.container !== "subnet" &&
         value.container !== "feedback")
         add("invalid-container", "container must be subnet or feedback", "container");
+    if (value.source !== undefined && value.source !== "live")
+        add("invalid-source", "source must be \"live\" when present", "source");
     const allowed = ALLOWED[environment] ?? [];
     if (value.capabilities !== undefined && !Array.isArray(value.capabilities))
         add("invalid-capabilities", "capabilities must be an array", "capabilities");
@@ -193,6 +195,8 @@ export function validateNodeDefinition(value) {
                 add("invalid-type", `${String(type)} is not a Cascade type`, `${path}.type`);
                 continue;
             }
+            if (section !== "props")
+                result.push(...bundleDiagnostics(raw, type, section, path));
             if (type === "texture" && environment !== "browser")
                 add("texture-not-portable", "texture is browser-only", `${path}.type`);
             if (type === "texture" && "default" in raw)
@@ -229,6 +233,58 @@ export function validateNodeDefinition(value) {
     }
     return result;
 }
+/** `schema` and `fields` on a port: bundle-only, and well-formed. */
+function bundleDiagnostics(raw, type, section, path) {
+    const result = [];
+    const add = (code, message, at) => result.push(diagnostic(code, message, at));
+    for (const key of ["schema", "fields"])
+        if (key in raw && type !== "bundle")
+            add("bundle-metadata", `${key} is only valid on a bundle port`, `${path}.${key}`);
+    if (type !== "bundle")
+        return result;
+    if ("schema" in raw && (typeof raw.schema !== "string" || !IDENTIFIER.test(raw.schema)))
+        add("invalid-schema", "schema must be an identifier", `${path}.schema`);
+    if (!("fields" in raw))
+        return result;
+    const declared = raw.fields;
+    if (section === "inputs") {
+        if (!Array.isArray(declared)) {
+            add("invalid-fields", "an input's fields list the field names it reads", `${path}.fields`);
+            return result;
+        }
+        const seen = new Set();
+        for (const [index, field] of declared.entries()) {
+            if (typeof field !== "string" || !IDENTIFIER.test(field))
+                add("invalid-field", `${String(field)} is not a valid field name`, `${path}.fields[${index}]`);
+            else if (seen.has(field))
+                add("duplicate-field", `${field} is listed twice`, `${path}.fields[${index}]`);
+            else
+                seen.add(field);
+        }
+        return result;
+    }
+    if (!isRecord(declared)) {
+        add("invalid-fields", "an output's fields map each field name to its type", `${path}.fields`);
+        return result;
+    }
+    for (const [field, definition] of Object.entries(declared)) {
+        const at = `${path}.fields.${field}`;
+        if (!IDENTIFIER.test(field) || RESERVED.has(field))
+            add("invalid-field", `${field} is not a valid field name`, at);
+        const fieldType = typeof definition === "string"
+            ? definition
+            : isRecord(definition) ? definition.type : undefined;
+        if (isRecord(definition))
+            for (const key of Object.keys(definition))
+                if (key !== "type" && key !== "description")
+                    add("unknown-field", `${at}.${key} is not allowed`, `${at}.${key}`);
+        if (!validType(fieldType))
+            add("invalid-type", `${String(fieldType)} is not a Cascade type`, at);
+        else if (fieldType === "texture")
+            add("texture-not-portable", "a bundle field cannot hold a texture", at);
+    }
+    return result;
+}
 export function assertNodeDefinition(value) {
     const diagnostics = validateNodeDefinition(value);
     if (diagnostics.length)

package/dist/contracts/values.d.ts

@@ -2,7 +2,7 @@ import type { Camera } from "./camera.js";
 import type { Color } from "./color.js";
 import type { Light, Scene } from "./scene.js";
 import type { Geometry, GeometryFileRef, GeometryJson, GeometrySerialized } from "./geometry.js";
-export declare const CORE_TYPES: readonly ["float", "int", "bool", "string", "vec2", "vec3", "vec4", "vec2i", "vec3i", "vec4i", "mat2", "mat3", "mat4", "image", "texture", "geometry", "points", "lines", "polyline", "mesh", "rects", "color", "camera", "scene", "light", "asset", "array", "object", "any"];
+export declare const CORE_TYPES: readonly ["float", "int", "bool", "string", "vec2", "vec3", "vec4", "vec2i", "vec3i", "vec4i", "mat2", "mat3", "mat4", "image", "texture", "geometry", "points", "lines", "polyline", "mesh", "rects", "color", "camera", "scene", "light", "asset", "array", "object", "bundle", "any"];
 export type CoreType = (typeof CORE_TYPES)[number];
 export type NamespacedType = `${string}.${string}`;
 export type CascadeType = CoreType | NamespacedType;
@@ -96,7 +96,7 @@ export interface AssetRef {
     readonly mediaType?: string;
 }
 export type SerializableValue = JsonValue | AssetRef | ImageRef | GeometryJson | GeometryFileRef;
-export type ValueForType<T extends CascadeType> = T extends "float" | "int" ? number : T extends "bool" ? boolean : T extends "string" ? string : T extends "vec2" ? Vec2 : T extends "vec3" ? Vec3 : T extends "vec4" ? Vec4 : T extends "vec2i" ? Vec2i : T extends "vec3i" ? Vec3i : T extends "vec4i" ? Vec4i : T extends "mat2" ? Mat2 : T extends "mat3" ? Mat3 : T extends "mat4" ? Mat4 : T extends "color" ? Color : T extends "camera" ? Camera : T extends "scene" ? Scene : T extends "light" ? Light : T extends "image" ? ImageRef : T extends "texture" ? TextureHandle : T extends "geometry" ? Geometry : T extends "points" ? PointSet : T extends "lines" ? LineSegments : T extends "polyline" ? Polyline : T extends "mesh" ? Mesh : T extends "rects" ? Rects : T extends "asset" ? AssetRef : T extends "array" ? readonly unknown[] : T extends "object" ? Readonly<Record<string, unknown>> : unknown;
-export type SerializableValueForType<T extends CascadeType> = T extends "texture" ? never : T extends "geometry" ? GeometrySerialized : T extends "array" ? readonly JsonValue[] : T extends "object" ? Readonly<Record<string, JsonValue>> : T extends "any" | NamespacedType ? JsonValue : ValueForType<T>;
+export type ValueForType<T extends CascadeType> = T extends "float" | "int" ? number : T extends "bool" ? boolean : T extends "string" ? string : T extends "vec2" ? Vec2 : T extends "vec3" ? Vec3 : T extends "vec4" ? Vec4 : T extends "vec2i" ? Vec2i : T extends "vec3i" ? Vec3i : T extends "vec4i" ? Vec4i : T extends "mat2" ? Mat2 : T extends "mat3" ? Mat3 : T extends "mat4" ? Mat4 : T extends "color" ? Color : T extends "camera" ? Camera : T extends "scene" ? Scene : T extends "light" ? Light : T extends "image" ? ImageRef : T extends "texture" ? TextureHandle : T extends "geometry" ? Geometry : T extends "points" ? PointSet : T extends "lines" ? LineSegments : T extends "polyline" ? Polyline : T extends "mesh" ? Mesh : T extends "rects" ? Rects : T extends "asset" ? AssetRef : T extends "array" ? readonly unknown[] : T extends "object" | "bundle" ? Readonly<Record<string, unknown>> : unknown;
+export type SerializableValueForType<T extends CascadeType> = T extends "texture" ? never : T extends "geometry" ? GeometrySerialized : T extends "array" ? readonly JsonValue[] : T extends "object" | "bundle" ? Readonly<Record<string, JsonValue>> : T extends "any" | NamespacedType ? JsonValue : ValueForType<T>;
 export {};
 //# sourceMappingURL=values.d.ts.map

package/dist/contracts/values.js

@@ -27,6 +27,7 @@ export const CORE_TYPES = [
     "asset",
     "array",
     "object",
+    "bundle",
     "any",
 ];
 const TYPE_ALIASES = {

package/dist/image.d.ts

@@ -0,0 +1,141 @@
+/**
+ * `cascade/image` — the one image API a node body uses, in every host.
+ *
+ * A node that draws used to have two honest choices and one dishonest one.
+ * `new OffscreenCanvas` worked in Studio and under `cascade run` (the CLI
+ * installs Skia's canvas as that global), but the bytes in and out went
+ * through `cascade/io`'s project paths, and fonts had no portable door at all.
+ * So the nodes that needed fonts or files reached for `@napi-rs/canvas` and
+ * `node:fs` directly, declared `runsOn: 'server'`, and could never be exported
+ * as a browser editor — the commons plotter-social job was blocked on exactly
+ * that ("Cascade has no browser image contract").
+ *
+ * The contract, in full:
+ *
+ *  - **Surface.** `createCanvas(w, h)` is an `OffscreenCanvas`: the browser's
+ *    own in a page or a worker, Skia's (`@napi-rs/canvas`, installed by the
+ *    headless host) under `cascade run`/`render`/MCP. `context2d(canvas)` asks
+ *    for a CPU-backed 2D context (`willReadFrequently`), which is what keeps
+ *    Chrome on the same software Skia rasteriser the headless host uses, and
+ *    is the right hint anyway for nodes that read pixels back.
+ *  - **Pixels in.** `readImage(context, ref)` reads an `ImageRef`, `AssetRef`
+ *    or project path through the node's declared `assets` capability and
+ *    decodes it with `decodeImage` (`createImageBitmap` in both hosts).
+ *  - **Pixels out.** `writeImage(context, canvas, name)` encodes PNG through
+ *    `encodeImage` and stores it with `assets.write`, returning the `ImageRef`
+ *    to set on an `image` output. The host decides where it lands
+ *    (`.cascade-cache/<name>.<hash>.png` headless, an in-memory generated
+ *    asset in an exported editor), so a node never names a path.
+ *  - **Fonts.** `registerFont(family, bytes)` makes a face drawable by
+ *    `ctx.font` in this host: `FontFace` added to the page's or worker's font
+ *    set in a browser, Skia's `GlobalFonts` headless. Bytes come from the same
+ *    `assets` capability, so a font is a project file like any other.
+ *  - **Refusal, not fallback.** No canvas in this host, or no `assets`
+ *    capability declared, is an error with one sentence saying which, never a
+ *    silent blank image.
+ *
+ * A node using it declares `runsOn: 'portable'` and `capabilities: ['assets']`
+ * and imports nothing host-specific (`node:*`, `@napi-rs/canvas`, `document`).
+ * Then the same body cooks in Studio, in `cascade run`, and in an exported
+ * editor's worker.
+ *
+ * The headless host installs its font door under a global key, like
+ * `cascade/io`'s bridge, because the node's copy of this module and the CLI's
+ * copy are not always the same module instance.
+ */
+/** An image port value. Mirrors Cascade's core `ImageRef`. */
+export interface ImageRef {
+    path: string;
+    size: [number, number];
+    channels: 'r' | 'a' | 'rg' | 'rgb' | 'rgba';
+    depth: 'u8' | 'u16' | 'f16' | 'f32';
+    space: 'srgb' | 'linear';
+}
+/** Anything naming stored bytes: an `ImageRef`, an `AssetRef`, or a project path. */
+export type ImageSourceRef = string | {
+    readonly path: string;
+};
+/** The part of the `assets` capability these helpers use. */
+export interface ImageAssets {
+    read(ref: {
+        path: string;
+    }, options: {
+        signal: unknown;
+    }): Promise<Uint8Array>;
+    write(data: Uint8Array, metadata: {
+        mediaType?: string;
+        suggestedName?: string;
+    }, options: {
+        signal: unknown;
+    }): Promise<{
+        path: string;
+        mediaType?: string;
+    }>;
+}
+/**
+ * The slice of a definition-v1 `NodeExecutionContext` these helpers need, so
+ * a node passes its own `context`. Typed loosely on purpose: a node that did
+ * not declare `assets` still type-checks here and gets a sentence at run time
+ * naming the missing declaration rather than a type error about generics.
+ */
+export interface ImageNodeContext {
+    readonly capabilities: object;
+    readonly signal?: unknown;
+}
+export type ImageType = 'image/png' | 'image/webp' | 'image/jpeg';
+/** What a host gives `registerFont`. A browser realm needs none. */
+export interface ImageHost {
+    /** For a `--verbose` line and for errors. */
+    readonly renderer: string;
+    registerFont(family: string, bytes: Uint8Array, descriptors: FontDescriptors): void | Promise<void>;
+}
+export interface FontDescriptors {
+    /** CSS weight, `'400'`, `'bold'`. Headless reads the weight from the file. */
+    weight?: string;
+    /** `'normal'` or `'italic'`. Headless reads the style from the file. */
+    style?: string;
+}
+/** Install the headless host's font door. Returns the disposer. */
+export declare function installImageHost(host: ImageHost | null): () => void;
+/** Whether this host can draw. Never throws. */
+export declare function canvasAvailable(): boolean;
+/** A drawing surface of whole pixels, at least 1x1. */
+export declare function createCanvas(width: number, height: number): OffscreenCanvas;
+/**
+ * The canvas's 2D context, CPU-backed. `willReadFrequently` keeps a browser
+ * off the GPU rasteriser, so a node draws with the same software Skia in Chrome
+ * as headless, and `getImageData` does not stall on a readback.
+ */
+export declare function context2d(canvas: OffscreenCanvas): OffscreenCanvasRenderingContext2D;
+/** `createCanvas` and `context2d` in one: `const { canvas, context } = surface(w, h)`. */
+export declare function surface(width: number, height: number): {
+    canvas: OffscreenCanvas;
+    context: OffscreenCanvasRenderingContext2D;
+};
+/** Encoded bytes (PNG, JPEG, WebP) to something `drawImage` accepts. */
+export declare function decodeImage(bytes: Uint8Array | ArrayBuffer | Blob): Promise<ImageBitmap>;
+/** A canvas's pixels as encoded bytes, PNG unless asked otherwise. */
+export declare function encodeImage(canvas: OffscreenCanvas, options?: {
+    type?: ImageType;
+    quality?: number;
+}): Promise<Uint8Array>;
+/**
+ * Make `family` drawable by `ctx.font` here. Idempotent per family and bytes.
+ * A browser realm (page or worker) uses `FontFace`; the headless host
+ * registers with Skia. A host with neither refuses.
+ */
+export declare function registerFont(family: string, bytes: Uint8Array | ArrayBuffer, descriptors?: FontDescriptors): Promise<void>;
+/** A stored file's bytes through the node's `assets` capability: an image, a font, anything. */
+export declare function readBytes(context: ImageNodeContext, ref: ImageSourceRef): Promise<Uint8Array>;
+/** Read and decode an image input, an asset, or a project file. */
+export declare function readImage(context: ImageNodeContext, ref: ImageSourceRef): Promise<ImageBitmap>;
+/**
+ * Encode a canvas and store it; set the result on an `image` output. `name`
+ * is a suggestion (`context.nodeId + '.png'` keeps instances apart); the host
+ * picks the stored path.
+ */
+export declare function writeImage(context: ImageNodeContext, canvas: OffscreenCanvas, name: string, options?: {
+    type?: ImageType;
+    quality?: number;
+    space?: 'srgb' | 'linear';
+}): Promise<ImageRef>;

package/dist/image.js

@@ -0,0 +1,127 @@
+// server/src/runtime/image.ts
+var HOST_KEY = "__cascadeImageHost";
+var NO_CANVAS = 'cascade/image: this host has no canvas. In a browser this needs OffscreenCanvas; headless, Cascade installs @napi-rs/canvas before a run (install it with "npm install @napi-rs/canvas" if it is missing).';
+function installImageHost(host) {
+  const globals = globalThis;
+  const previous = globals[HOST_KEY];
+  globals[HOST_KEY] = host ?? void 0;
+  return () => {
+    globals[HOST_KEY] = previous;
+  };
+}
+function installedHost() {
+  const host = globalThis[HOST_KEY];
+  return host && typeof host.registerFont === "function" ? host : null;
+}
+function canvasConstructor() {
+  return globalThis.OffscreenCanvas;
+}
+function canvasAvailable() {
+  return typeof canvasConstructor() === "function";
+}
+function createCanvas(width, height) {
+  const Canvas = canvasConstructor();
+  if (!Canvas) throw new Error(NO_CANVAS);
+  return new Canvas(Math.max(1, Math.round(width)), Math.max(1, Math.round(height)));
+}
+function context2d(canvas) {
+  const context = canvas.getContext("2d", { willReadFrequently: true });
+  if (!context) throw new Error("cascade/image: the canvas has no 2D context");
+  return context;
+}
+function surface(width, height) {
+  const canvas = createCanvas(width, height);
+  return { canvas, context: context2d(canvas) };
+}
+async function decodeImage(bytes) {
+  const create = globalThis.createImageBitmap;
+  if (typeof create !== "function") throw new Error(NO_CANVAS);
+  const blob = bytes instanceof Blob ? bytes : new Blob([bytes]);
+  const image = await create(blob);
+  if (!image?.width || !image?.height) throw new Error("cascade/image: could not decode the image data");
+  return image;
+}
+async function encodeImage(canvas, options = {}) {
+  const type = options.type ?? "image/png";
+  if (typeof canvas.convertToBlob !== "function") throw new Error("cascade/image: this canvas cannot encode (no convertToBlob)");
+  const blob = await canvas.convertToBlob({ type, ...options.quality === void 0 ? {} : { quality: options.quality } });
+  return new Uint8Array(await blob.arrayBuffer());
+}
+var registered = /* @__PURE__ */ new Map();
+function fingerprint(bytes) {
+  let hash = 2166136261;
+  for (let index = 0; index < bytes.length; index += 1) {
+    hash ^= bytes[index];
+    hash = Math.imul(hash, 16777619);
+  }
+  return `${bytes.length}:${(hash >>> 0).toString(16)}`;
+}
+async function registerFont(family, bytes, descriptors = {}) {
+  if (!family.trim()) throw new Error("cascade/image: registerFont needs a family name");
+  const data = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+  if (!data.byteLength) throw new Error(`cascade/image: the font for ${family} is empty`);
+  const host = installedHost();
+  const globals = globalThis;
+  const fonts = host ? null : globals.fonts ?? globals.document?.fonts;
+  const realm = host ? `headless:${host.renderer}` : fonts ?? globalThis;
+  const key = `${family}\0${descriptors.weight ?? ""}\0${descriptors.style ?? ""}\0${fingerprint(data)}`;
+  const seen = registered.get(realm) ?? /* @__PURE__ */ new Set();
+  if (seen.has(key)) return;
+  if (host) {
+    await host.registerFont(family, data, descriptors);
+  } else if (typeof globals.FontFace === "function" && fonts) {
+    const face = new globals.FontFace(family, data.slice().buffer, descriptors);
+    fonts.add(await face.load());
+  } else {
+    throw new Error("cascade/image: this host cannot register fonts (no FontFace and no headless canvas host)");
+  }
+  seen.add(key);
+  registered.set(realm, seen);
+}
+function assetsOf(context) {
+  const assets = context.capabilities.assets;
+  if (!assets || typeof assets.read !== "function" || typeof assets.write !== "function") {
+    throw new Error("cascade/image: this node reads or writes images, so its definition must declare capabilities: ['assets']");
+  }
+  return assets;
+}
+function refOf(ref) {
+  const path = typeof ref === "string" ? ref : ref?.path;
+  if (typeof path !== "string" || !path) throw new Error("cascade/image: no image to read (an empty path or an unset image input)");
+  return { path };
+}
+var NEVER = { aborted: false, addEventListener() {
+}, removeEventListener() {
+} };
+async function readBytes(context, ref) {
+  return assetsOf(context).read(refOf(ref), { signal: context.signal ?? NEVER });
+}
+async function readImage(context, ref) {
+  return decodeImage(await readBytes(context, ref));
+}
+async function writeImage(context, canvas, name, options = {}) {
+  const type = options.type ?? "image/png";
+  const bytes = await encodeImage(canvas, { type, ...options.quality === void 0 ? {} : { quality: options.quality } });
+  const stored = await assetsOf(context).write(bytes, { mediaType: type, suggestedName: name }, { signal: context.signal ?? NEVER });
+  return {
+    path: stored.path,
+    size: [canvas.width, canvas.height],
+    channels: "rgba",
+    depth: "u8",
+    space: options.space ?? "srgb"
+  };
+}
+export {
+  canvasAvailable,
+  context2d,
+  createCanvas,
+  decodeImage,
+  encodeImage,
+  installImageHost,
+  readBytes,
+  readImage,
+  registerFont,
+  surface,
+  writeImage
+};
+//# sourceMappingURL=image.js.map

package/dist/index.html

@@ -6,11 +6,11 @@
   <!-- Pinterest browser extension: no Save buttons over canvases and previews -->
   <meta name="pinterest" content="nopin">
   <title>Cascade</title>
-  <script type="module" crossorigin src="/assets/index-CMiBdEuT.js"></script>
-  <link rel="modulepreload" crossorigin href="/assets/legacy-ZA7textG.js">
-  <link rel="modulepreload" crossorigin href="/assets/index-client-BI2H82FJ.js">
+  <script type="module" crossorigin src="/assets/index-5ZtDAuy2.js"></script>
+  <link rel="modulepreload" crossorigin href="/assets/legacy-CTEeXeqF.js">
+  <link rel="modulepreload" crossorigin href="/assets/index-client-DqYmKstU.js">
   <link rel="modulepreload" crossorigin href="/assets/nodeTypeUtils-BDJsc2Ks.js">
-  <link rel="stylesheet" crossorigin href="/assets/index-DMIuml9a.css">
+  <link rel="stylesheet" crossorigin href="/assets/index-7vae6YFC.css">
 </head>
 <body>
   <div id="app"></div>

package/dist/player/app.js

@@ -474,7 +474,7 @@ var BrowserPlayer = class {
     }
     if (typeof value === "string") {
       return new Blob([value], {
-        type: value.trimStart().startsWith("<svg") ? "image/svg+xml" : "text/plain;charset=utf-8"
+        type: isSvgText(value) ? "image/svg+xml" : "text/plain;charset=utf-8"
       });
     }
     if ((isGeometry(value) || isScene(value)) && this.displayedElement instanceof HTMLCanvasElement)
@@ -572,7 +572,7 @@ var BrowserPlayer = class {
     let next;
     let nextRelease;
     const asset = isAssetRef(value) ? value : void 0;
-    if (asset || typeof value === "string" && value.trimStart().startsWith("<svg")) {
+    if (asset || isSvgText(value)) {
       let url;
       if (asset) {
         const lease = await this.context.assets.resolveUrl(asset);
@@ -692,13 +692,13 @@ function createUi(hostDocument, root) {
   root.append(toolbar, error, output);
   return { play, frame, error, output };
 }
-function renderSceneCanvas(hostDocument, scene, width, height) {
+function renderSceneCanvas(hostDocument, scene, width, height, stroke = [1, 1, 1, 1]) {
   let canvas;
   const camera = scene.camera ?? fitCamera(scene, width, height);
   renderScene(scene.geometry, {
     camera,
     size: [width, height],
-    stroke: [1, 1, 1, 1],
+    stroke: [...stroke],
     strokeWidth: 1,
     opacity: 1,
     pointRadius: 1,
@@ -753,7 +753,7 @@ function preferredOutput(result) {
   for (const [nodeId, outputs] of result.outputs) {
     for (const [port, value] of outputs) {
       fallback = { nodeId, port };
-      if (isAssetRef(value) || isScene(value) || isGeometry(value) || typeof value === "string" && value.trimStart().startsWith("<svg"))
+      if (isAssetRef(value) || isScene(value) || isGeometry(value) || isSvgText(value))
         preferred = { nodeId, port };
     }
   }
@@ -805,6 +805,18 @@ function requireFinite(value, label) {
 function asError(value) {
   return value instanceof Error ? value : new Error(String(value));
 }
+function isSvgText(value) {
+  return typeof value === "string" && /^\s*(?:<\?xml[^>]*>\s*)?(?:<!--[\s\S]*?-->\s*|<!DOCTYPE[^>]*>\s*)*<svg[\s>]/i.test(value.slice(0, 2e3));
+}
 export {
+  asError,
+  canvasBlob,
+  cleanupAll,
+  isAssetRef,
+  isGeometry,
+  isImageAsset,
+  isSvgText,
+  jsonReplacer,
+  renderSceneCanvas,
   startPlayer
 };