@field/cascade 0.10.0 → 0.12.0

package/dist/cli/chunk-DEQSEFFH.js

@@ -0,0 +1,153 @@
+// packages/runtime/src/camera/index.ts
+var DEG = Math.PI / 180;
+function cross(a, b) {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}
+function normalize(v) {
+  const length = Math.hypot(v[0], v[1], v[2]);
+  if (length === 0) return [0, 0, 0];
+  return [v[0] / length, v[1] / length, v[2] / length];
+}
+function subtract(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function lookAtRotation(from, to, up = [0, 1, 0]) {
+  const forward = normalize(subtract(to, from));
+  if (forward[0] === 0 && forward[1] === 0 && forward[2] === 0) return [0, 0, 0];
+  const horizontal = Math.hypot(forward[0], forward[2]);
+  const pitch = Math.atan2(forward[1], horizontal);
+  const yaw = Math.atan2(-forward[0], -forward[2]);
+  return [pitch / DEG, yaw / DEG, rollTowards(forward, pitch, yaw, up) / DEG];
+}
+function rollTowards(forward, pitch, yaw, up) {
+  const desired = normalize([
+    up[0] - forward[0] * dot(up, forward),
+    up[1] - forward[1] * dot(up, forward),
+    up[2] - forward[2] * dot(up, forward)
+  ]);
+  if (desired[0] === 0 && desired[1] === 0 && desired[2] === 0) return 0;
+  const locked = cameraBasis({
+    ...CAMERA_ROTATION_ONLY,
+    rotate: [pitch / DEG, yaw / DEG, 0]
+  }).up;
+  return Math.atan2(dot(cross(desired, locked), forward), dot(locked, desired));
+}
+var CAMERA_ROTATION_ONLY = {
+  translate: [0, 0, 0],
+  focal: 50,
+  aperture: 41.4214,
+  near: 1e-3,
+  far: 1e4,
+  resolution: [1, 1],
+  aspect: 1,
+  projection: "perspective",
+  orthowidth: 2
+};
+function cameraBasis(camera) {
+  const [rx, ry, rz] = camera.rotate;
+  const sx = Math.sin(rx * DEG);
+  const cx = Math.cos(rx * DEG);
+  const sy = Math.sin(ry * DEG);
+  const cy = Math.cos(ry * DEG);
+  const sz = Math.sin(rz * DEG);
+  const cz = Math.cos(rz * DEG);
+  const m00 = cy * cz + sy * sx * sz;
+  const m01 = -cy * sz + sy * sx * cz;
+  const m02 = sy * cx;
+  const m10 = cx * sz;
+  const m11 = cx * cz;
+  const m12 = -sx;
+  const m20 = -sy * cz + cy * sx * sz;
+  const m21 = sy * sz + cy * sx * cz;
+  const m22 = cy * cx;
+  const right = [m00, m10, m20];
+  const up = [m01, m11, m21];
+  const forward = [-m02, -m12, -m22];
+  return { eye: camera.translate, forward, right, up };
+}
+function frameAspect(camera) {
+  const [width, height] = camera.resolution;
+  if (height === 0) return 1;
+  return width * camera.aspect / height;
+}
+function viewMatrix(camera) {
+  const { eye, forward, right, up } = cameraBasis(camera);
+  const back = [-forward[0], -forward[1], -forward[2]];
+  return [
+    right[0],
+    up[0],
+    back[0],
+    0,
+    right[1],
+    up[1],
+    back[1],
+    0,
+    right[2],
+    up[2],
+    back[2],
+    0,
+    -(right[0] * eye[0] + right[1] * eye[1] + right[2] * eye[2]),
+    -(up[0] * eye[0] + up[1] * eye[1] + up[2] * eye[2]),
+    -(back[0] * eye[0] + back[1] * eye[1] + back[2] * eye[2]),
+    1
+  ];
+}
+function projectionMatrix(camera) {
+  const { near, far } = camera;
+  const aspect = frameAspect(camera);
+  if (camera.projection === "orthographic") {
+    const halfWidth = camera.orthowidth / 2;
+    const halfHeight = aspect === 0 ? halfWidth : halfWidth / aspect;
+    return [
+      1 / halfWidth,
+      0,
+      0,
+      0,
+      0,
+      1 / halfHeight,
+      0,
+      0,
+      0,
+      0,
+      -2 / (far - near),
+      0,
+      0,
+      0,
+      -(far + near) / (far - near),
+      1
+    ];
+  }
+  const focalScale = 2 * camera.focal / camera.aperture;
+  return [
+    focalScale,
+    0,
+    0,
+    0,
+    0,
+    focalScale * aspect,
+    0,
+    0,
+    0,
+    0,
+    -(far + near) / (far - near),
+    -1,
+    0,
+    0,
+    -2 * far * near / (far - near),
+    0
+  ];
+}
+
+export {
+  lookAtRotation,
+  viewMatrix,
+  projectionMatrix
+};
+//# sourceMappingURL=chunk-DEQSEFFH.js.map

package/dist/cli/chunk-EU4ZFZ7Y.js

@@ -0,0 +1,122 @@
+import {
+  readProjectManifest
+} from "./chunk-2JEU3MGB.js";
+
+// server/src/compile.ts
+import * as esbuild from "esbuild";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var __dirname_compile = path.dirname(fileURLToPath(import.meta.url));
+function cascadeRuntimePlugin(project) {
+  return {
+    name: "cascade-runtime",
+    setup(build2) {
+      build2.onResolve({ filter: /^cascade\/(?:io|image|shell|net|config|stage)$/ }, (args) => ({
+        path: args.path,
+        namespace: "cascade-runtime"
+      }));
+      build2.onResolve({ filter: /^(?:@cascade|cascade)\/contracts$/ }, () => {
+        const candidates = [
+          path.join(__dirname_compile, "..", "contracts", "index.js"),
+          path.join(__dirname_compile, "..", "..", "packages", "contracts", "dist", "index.js")
+        ];
+        const found = candidates.find((c) => fs.existsSync(c));
+        if (!found) {
+          return { errors: [{ text: `@cascade/contracts not found (looked in ${candidates.join(", ")})` }] };
+        }
+        return { path: found };
+      });
+      build2.onLoad({ filter: /.*/, namespace: "cascade-runtime" }, (args) => {
+        if (args.path === "cascade/config") {
+          return { contents: configRuntimeSource(readProjectManifest(project.root).settings), loader: "ts" };
+        }
+        const candidates = [
+          path.join(__dirname_compile, "runtime", `${args.path.slice("cascade/".length)}.ts`),
+          path.join(__dirname_compile, "..", "src", "runtime", `${args.path.slice("cascade/".length)}.ts`)
+        ];
+        const found = candidates.find((c) => fs.existsSync(c));
+        if (!found) {
+          return { errors: [{ text: `${args.path} runtime not found (looked in ${candidates.join(", ")})` }] };
+        }
+        return { contents: fs.readFileSync(found, "utf-8"), loader: "ts", resolveDir: path.dirname(found) };
+      });
+    }
+  };
+}
+function commonOptions(project) {
+  return {
+    bundle: true,
+    format: "esm",
+    platform: "browser",
+    target: "es2022",
+    write: false,
+    logLevel: "silent",
+    plugins: [cascadeRuntimePlugin(project)]
+  };
+}
+async function compileProjectModule(project, moduleName) {
+  try {
+    await project.moduleRunsOn(moduleName);
+    return await compileEntry(project, project.resolve(`nodes/${moduleName}/index.ts`));
+  } catch (err) {
+    return { ok: false, code: "", errors: [errorMessage(err)] };
+  }
+}
+async function compileProjectPanel(project, panelName) {
+  try {
+    return await compileEntry(project, await project.resolvePanelEntry(panelName));
+  } catch (err) {
+    return { ok: false, code: "", errors: [errorMessage(err)] };
+  }
+}
+async function compileEmbedded(project, code) {
+  try {
+    const result = await esbuild.build({
+      ...commonOptions(project),
+      stdin: {
+        contents: code,
+        loader: "ts",
+        resolveDir: project.root,
+        sourcefile: "embedded.ts"
+      }
+    });
+    return toResult(result);
+  } catch (err) {
+    return { ok: false, code: "", errors: [errorMessage(err)] };
+  }
+}
+function toResult(result) {
+  const errors = result.errors.map((e) => e.text);
+  const code = result.outputFiles?.[0]?.text ?? "";
+  return { ok: errors.length === 0, code, errors };
+}
+async function compileEntry(project, entryPath) {
+  return toResult(await esbuild.build({ ...commonOptions(project), entryPoints: [entryPath] }));
+}
+function configRuntimeSource(settings) {
+  return `function deepFreeze(value) { if (value && typeof value === 'object') { for (const item of Object.values(value)) deepFreeze(item); Object.freeze(value); } return value; }
+const values = deepFreeze(${JSON.stringify(settings)});
+function value(name) { return Object.prototype.hasOwnProperty.call(values, name) ? values[name] : undefined; }
+export const config = Object.freeze({
+  get(name, fallback) { return value(name) ?? fallback; },
+  string(name, fallback = '') { const item = value(name); return typeof item === 'string' ? item : fallback; },
+  number(name, fallback = 0) { const item = value(name); return typeof item === 'number' && Number.isFinite(item) ? item : fallback; },
+  boolean(name, fallback = false) { const item = value(name); return typeof item === 'boolean' ? item : fallback; },
+  has(name) { return value(name) !== undefined; }
+});`;
+}
+function errorMessage(err) {
+  if (err && typeof err === "object" && "errors" in err) {
+    const errors = err.errors;
+    if (errors?.length) return errors.map((e) => e.text).join("\n");
+  }
+  return err instanceof Error ? err.message : String(err);
+}
+
+export {
+  compileProjectModule,
+  compileProjectPanel,
+  compileEmbedded
+};
+//# sourceMappingURL=chunk-EU4ZFZ7Y.js.map

package/dist/cli/chunk-EZRWJ4G2.js

@@ -0,0 +1,104 @@
+// server/src/runtime/image.ts
+var HOST_KEY = "__cascadeImageHost";
+function installImageHost(host) {
+  const globals = globalThis;
+  const previous = globals[HOST_KEY];
+  globals[HOST_KEY] = host ?? void 0;
+  return () => {
+    globals[HOST_KEY] = previous;
+  };
+}
+
+// src/cli/headlessCanvas.ts
+var CANVAS_PACKAGE = "@napi-rs/canvas";
+var MISSING_CANVAS_MESSAGE = `Cascade cannot render offline: no canvas is available in this Node process. Install the optional renderer with "npm install ${CANVAS_PACKAGE}" and run again. (It is optional because it is a native, platform-specific binding \u2014 Cascade installs cleanly without it, but a node drawing with OffscreenCanvas or Canvas 2D needs it.)`;
+var MissingCanvasError = class extends Error {
+  constructor(cause) {
+    super(MISSING_CANVAS_MESSAGE);
+    this.name = "MissingCanvasError";
+    if (cause !== void 0) this.cause = cause;
+  }
+};
+var modulePromise;
+async function loadCanvasModule() {
+  modulePromise ??= import(
+    /* @vite-ignore */
+    CANVAS_PACKAGE
+  ).then((module) => module.default ?? module).catch((error) => {
+    modulePromise = void 0;
+    throw new MissingCanvasError(error);
+  });
+  return modulePromise;
+}
+async function canvasAvailable() {
+  try {
+    await loadCanvasModule();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installHeadlessCanvas() {
+  const canvas = await loadCanvasModule();
+  const globals = globalThis;
+  class HeadlessOffscreenCanvas extends canvas.Canvas {
+    async convertToBlob(options = {}) {
+      const type = options.type ?? "image/png";
+      const format = type.replace(/^image\//, "");
+      const quality = options.quality === void 0 ? void 0 : Math.round(options.quality * 100);
+      return new Blob([await this.encode(format, quality)], { type });
+    }
+  }
+  const createBitmap = async (source) => {
+    const bytes = source instanceof Uint8Array ? source : new Uint8Array(source instanceof Blob ? await source.arrayBuffer() : source);
+    const image = new canvas.Image();
+    image.src = bytes;
+    await image.decode();
+    if (!image.width || !image.height) throw new Error("cascade: could not decode image data");
+    image.close = () => {
+    };
+    return image;
+  };
+  const installed = {
+    OffscreenCanvas: HeadlessOffscreenCanvas,
+    Image: canvas.Image,
+    ImageData: canvas.ImageData,
+    Path2D: canvas.Path2D,
+    DOMMatrix: canvas.DOMMatrix,
+    DOMPoint: canvas.DOMPoint,
+    DOMRect: canvas.DOMRect,
+    createImageBitmap: createBitmap
+  };
+  const previous = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(installed)) {
+    if (value === void 0) continue;
+    previous.set(name, globals[name]);
+    globals[name] = value;
+  }
+  const renderer = `${CANVAS_PACKAGE} (Skia)`;
+  const disposeImageHost = installImageHost({
+    renderer,
+    registerFont(family, bytes) {
+      canvas.GlobalFonts.register(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength), family);
+    }
+  });
+  return {
+    renderer,
+    dispose() {
+      disposeImageHost();
+      for (const [name, value] of previous) {
+        if (value === void 0) delete globals[name];
+        else globals[name] = value;
+      }
+    }
+  };
+}
+
+export {
+  CANVAS_PACKAGE,
+  MISSING_CANVAS_MESSAGE,
+  MissingCanvasError,
+  canvasAvailable,
+  installHeadlessCanvas
+};
+//# sourceMappingURL=chunk-EZRWJ4G2.js.map

package/dist/cli/chunk-FWMSGKEH.js

@@ -0,0 +1,71 @@
+// packages/contracts/src/values.ts
+var CORE_TYPES = [
+  "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"
+];
+var TYPE_ALIASES = {
+  number: "float",
+  boolean: "bool",
+  curves: "polyline"
+};
+var IMPLICIT_TYPE_CONVERSIONS = {
+  int: ["float", "string"],
+  float: ["string"],
+  bool: ["int", "float", "string"],
+  vec2i: ["vec2"],
+  vec3i: ["vec3"],
+  vec4i: ["vec4"],
+  /**
+   * A geometry *is* a scene — one with the viewport's own camera and no lights.
+   * So the wire is legal and nothing is lost, which is the widening rule this
+   * table already follows. Every consumer of a `scene` input reads it through
+   * `asScene`, which performs the promotion; see `scene.ts`.
+   */
+  geometry: ["scene"],
+  vec4: ["color"],
+  color: ["vec4"]
+};
+function normalizeCascadeType(type) {
+  if (!type) return "any";
+  return TYPE_ALIASES[type] ?? type;
+}
+function canConnectTypes(source, target) {
+  const from = normalizeCascadeType(source);
+  const to = normalizeCascadeType(target);
+  return from === to || from === "any" || to === "any" || (IMPLICIT_TYPE_CONVERSIONS[from]?.includes(to) ?? false);
+}
+
+export {
+  CORE_TYPES,
+  normalizeCascadeType,
+  canConnectTypes
+};
+//# sourceMappingURL=chunk-FWMSGKEH.js.map