@xenosystem/blocks 0.21.0 → 0.23.0

package/dist/auth/index.d.ts

@@ -252,6 +252,12 @@ interface XenoAuthGateState {
     message?: string;
     /** For `expired-offline`: when the licence was last confirmed, so the plate can say how long ago. */
     lastVerifiedAt?: number;
+    /**
+     * The host name the system browser opens for sign-in (`xenosystem.ai`), as the HOST knows it — the gate
+     * does not. Named on the sign-in plate only when it is a plain host name; absent, the plate names no domain
+     * rather than guess one (apps sign in at different origins while the domain moves).
+     */
+    signInHost?: string;
     /** Which intents the host implements. A missing one hides its affordance (COMPONENTS §1.7). */
     capabilities?: Partial<Record<XenoAuthGateIntentKind, boolean>>;
 }

package/dist/auth/index.js

@@ -131,6 +131,11 @@ import { useEffect, useState } from "react";
 import { AuthDoor, SignInForm } from "@xenosystem/components/auth";
 
 // src/auth/gate/behaviour.ts
+var HOST = /^(?=.{3,253}$)[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+$/i;
+function signInNote(signInHost, productName) {
+  const where = signInHost && HOST.test(signInHost) ? `at ${signInHost.toLowerCase()}` : "to sign in";
+  return `Your browser opens ${where}, where you can continue with Google, GitHub or email. ${productName} never sees your password.`;
+}
 function authGateView(state, productName, now = Date.now()) {
   const phase = deriveAuthGatePhase(state);
   const copy = plateCopy(phase, productName, state.message, formatSince(state.lastVerifiedAt, now));
@@ -159,7 +164,7 @@ function authGateView(state, productName, now = Date.now()) {
     tag: copy.tag,
     title: copy.title,
     body: copy.body,
-    note: phase === "sign-in" && !state.pending ? `Your browser opens at xenostudio.ai, where you can continue with Google, GitHub or email. ${productName} never sees your password.` : void 0,
+    note: phase === "sign-in" && !state.pending ? signInNote(state.signInHost, productName) : void 0,
     warning: copy.note,
     identity: state.identity && phase !== "sign-in" ? state.identity.email ?? state.identity.name ?? state.identity.sub : void 0,
     actions

package/dist/chunk-76V25B3E.js

@@ -0,0 +1,435 @@
+// src/edit/curve/scale.ts
+var DEFAULT_CURVE_ZOOM = { min: 5e-4, max: 64 };
+var XenoCurveScale = class _XenoCurveScale {
+  pxPerTick;
+  scrollTick;
+  minValue;
+  maxValue;
+  widthPx;
+  heightPx;
+  gutterPx;
+  rulerPx;
+  constructor(state, geometry) {
+    this.widthPx = Math.max(1, finiteOr(geometry.widthPx, 1));
+    this.heightPx = Math.max(1, finiteOr(geometry.heightPx, 1));
+    this.gutterPx = Math.max(0, Math.min(finiteOr(geometry.gutterPx, 0), this.widthPx - 1));
+    this.rulerPx = Math.max(0, Math.min(finiteOr(geometry.rulerPx, 0), this.heightPx - 1));
+    this.pxPerTick = Math.max(Number.MIN_VALUE, finiteOr(state.pxPerTick, 1));
+    this.scrollTick = finiteOr(state.scrollTick, 0);
+    const min = finiteOr(state.minValue, 0);
+    const max = finiteOr(state.maxValue, 1);
+    if (max - min < 1e-12) {
+      const centre = (max + min) / 2;
+      this.minValue = centre - 0.5;
+      this.maxValue = centre + 0.5;
+    } else {
+      this.minValue = min;
+      this.maxValue = max;
+    }
+  }
+  /** Width of the plot area. Always ≥ 1. */
+  get plotPx() {
+    return Math.max(1, this.widthPx - this.gutterPx);
+  }
+  /** Height of the plot area. Always ≥ 1. */
+  get plotHeightPx() {
+    return Math.max(1, this.heightPx - this.rulerPx);
+  }
+  /** Ticks visible. */
+  get spanTicks() {
+    return this.plotPx / this.pxPerTick;
+  }
+  /** Tick at the right edge. */
+  get endTick() {
+    return this.scrollTick + this.spanTicks;
+  }
+  /** Value units per pixel. */
+  get valuePerPx() {
+    return (this.maxValue - this.minValue) / this.plotHeightPx;
+  }
+  /** Container-relative x → tick. */
+  xToTick(x) {
+    return this.scrollTick + (finiteOr(x, 0) - this.gutterPx) / this.pxPerTick;
+  }
+  /** Tick → container-relative x. */
+  tickToX(tick) {
+    return this.gutterPx + (finiteOr(tick, 0) - this.scrollTick) * this.pxPerTick;
+  }
+  /**
+   * Container-relative y → value.
+   *
+   * **Inverted.** Screen y grows downward, value grows upward. Every sign error in a graph editor
+   * lives on this one line.
+   */
+  yToValue(y) {
+    const local = finiteOr(y, 0) - this.rulerPx;
+    return this.maxValue - local / this.plotHeightPx * (this.maxValue - this.minValue);
+  }
+  /** Value → container-relative y. */
+  valueToY(value) {
+    const fraction = (this.maxValue - finiteOr(value, 0)) / (this.maxValue - this.minValue);
+    return this.rulerPx + fraction * this.plotHeightPx;
+  }
+  /**
+   * A tick DURATION → a pixel width.
+   *
+   * Separate from {@link tickToX}, because rounding is not associative: mixing
+   * `durationToPx(b - a)` with `tickToX(b) - tickToX(a)` puts a curve's handle a pixel off its key
+   * at some zoom levels and not others.
+   */
+  durationToPx(ticks) {
+    return finiteOr(ticks, 0) * this.pxPerTick;
+  }
+  /** A value DELTA → a pixel height. Sign-preserving and NOT inverted. */
+  valueDeltaToPx(delta) {
+    return finiteOr(delta, 0) / (this.maxValue - this.minValue) * this.plotHeightPx;
+  }
+  /** A pixel distance → a tick distance. For screen-space thresholds. */
+  pxToTicks(px) {
+    return finiteOr(px, 0) / this.pxPerTick;
+  }
+  /** A pixel distance → a value distance. For screen-space thresholds. */
+  pxToValue(px) {
+    return finiteOr(px, 0) * this.valuePerPx;
+  }
+  /** Is this point inside the plot area? */
+  isInPlot(x, y) {
+    return x >= this.gutterPx && x <= this.widthPx && y >= this.rulerPx && y <= this.heightPx;
+  }
+  /** A copy with new state. */
+  with(state) {
+    return new _XenoCurveScale(
+      {
+        pxPerTick: state.pxPerTick ?? this.pxPerTick,
+        scrollTick: state.scrollTick ?? this.scrollTick,
+        minValue: state.minValue ?? this.minValue,
+        maxValue: state.maxValue ?? this.maxValue
+      },
+      {
+        widthPx: this.widthPx,
+        heightPx: this.heightPx,
+        gutterPx: this.gutterPx,
+        rulerPx: this.rulerPx
+      }
+    );
+  }
+  /** A copy with new geometry. */
+  resized(geometry) {
+    return new _XenoCurveScale(
+      {
+        pxPerTick: this.pxPerTick,
+        scrollTick: this.scrollTick,
+        minValue: this.minValue,
+        maxValue: this.maxValue
+      },
+      {
+        widthPx: geometry.widthPx ?? this.widthPx,
+        heightPx: geometry.heightPx ?? this.heightPx,
+        gutterPx: geometry.gutterPx ?? this.gutterPx,
+        rulerPx: geometry.rulerPx ?? this.rulerPx
+      }
+    );
+  }
+};
+function finiteOr(value, fallback) {
+  return Number.isFinite(value) ? value : fallback;
+}
+function zoomTimeAboutCursor(scale, x, factor, bounds = DEFAULT_CURVE_ZOOM) {
+  const anchorTick = scale.xToTick(x);
+  const requested = scale.pxPerTick * (Number.isFinite(factor) && factor > 0 ? factor : 1);
+  const pxPerTick = Math.min(bounds.max, Math.max(bounds.min, requested));
+  return {
+    pxPerTick,
+    scrollTick: anchorTick - (x - scale.gutterPx) / pxPerTick,
+    minValue: scale.minValue,
+    maxValue: scale.maxValue
+  };
+}
+function zoomValueAboutCursor(scale, y, factor) {
+  const anchorValue = scale.yToValue(y);
+  const safeFactor = Number.isFinite(factor) && factor > 0 ? factor : 1;
+  const span = (scale.maxValue - scale.minValue) / safeFactor;
+  const fraction = (scale.maxValue - anchorValue) / (scale.maxValue - scale.minValue);
+  const maxValue = anchorValue + span * fraction;
+  return {
+    pxPerTick: scale.pxPerTick,
+    scrollTick: scale.scrollTick,
+    minValue: maxValue - span,
+    maxValue
+  };
+}
+function wheelZoomFactor(deltaY, sensitivity = 0.01) {
+  const raw = Number.isFinite(deltaY) ? deltaY : 0;
+  const clamped = Math.max(-10, Math.min(10, raw));
+  return Math.pow(2, -clamped * sensitivity * 10);
+}
+function fitValueRange(extent, marginFraction = 0.1) {
+  if (!extent || !Number.isFinite(extent.min) || !Number.isFinite(extent.max)) {
+    return { minValue: 0, maxValue: 1 };
+  }
+  const span = extent.max - extent.min;
+  const margin = Math.max(span * marginFraction, 0.5);
+  return { minValue: extent.min - margin, maxValue: extent.max + margin };
+}
+
+// src/edit/nodegraph/scale.ts
+var DEFAULT_GRAPH_ZOOM = { min: 0.05, max: 4 };
+var XenoGraphScale = class _XenoGraphScale {
+  zoom;
+  x;
+  y;
+  widthPx;
+  heightPx;
+  constructor(state, geometry) {
+    this.widthPx = Math.max(1, finiteOr2(geometry.widthPx, 1));
+    this.heightPx = Math.max(1, finiteOr2(geometry.heightPx, 1));
+    this.zoom = Math.max(Number.MIN_VALUE, finiteOr2(state.zoom, 1));
+    this.x = finiteOr2(state.x, 0);
+    this.y = finiteOr2(state.y, 0);
+  }
+  /** Graph-space width of the viewport. */
+  get graphWidth() {
+    return this.widthPx / this.zoom;
+  }
+  /** Graph-space height of the viewport. */
+  get graphHeight() {
+    return this.heightPx / this.zoom;
+  }
+  /** The visible rectangle in graph space. */
+  get viewport() {
+    return { x: this.x, y: this.y, width: this.graphWidth, height: this.graphHeight };
+  }
+  /** Container-relative screen point → graph point. */
+  screenToGraph(px, py) {
+    return { x: this.x + finiteOr2(px, 0) / this.zoom, y: this.y + finiteOr2(py, 0) / this.zoom };
+  }
+  /** Graph point → container-relative screen point. */
+  graphToScreen(gx, gy) {
+    return { x: (finiteOr2(gx, 0) - this.x) * this.zoom, y: (finiteOr2(gy, 0) - this.y) * this.zoom };
+  }
+  /** A graph-space distance → pixels. */
+  toPx(distance) {
+    return finiteOr2(distance, 0) * this.zoom;
+  }
+  /** A pixel distance → graph space. Used for screen-space hit thresholds. */
+  toGraph(px) {
+    return finiteOr2(px, 0) / this.zoom;
+  }
+  /** A copy with new state. */
+  with(state) {
+    return new _XenoGraphScale(
+      { zoom: state.zoom ?? this.zoom, x: state.x ?? this.x, y: state.y ?? this.y },
+      { widthPx: this.widthPx, heightPx: this.heightPx }
+    );
+  }
+  /** A copy with new geometry. */
+  resized(geometry) {
+    return new _XenoGraphScale(
+      { zoom: this.zoom, x: this.x, y: this.y },
+      { widthPx: geometry.widthPx ?? this.widthPx, heightPx: geometry.heightPx ?? this.heightPx }
+    );
+  }
+};
+function finiteOr2(value, fallback) {
+  return Number.isFinite(value) ? value : fallback;
+}
+function zoomAboutCursor(scale, px, py, factor, bounds = DEFAULT_GRAPH_ZOOM) {
+  const anchor = scale.screenToGraph(px, py);
+  const requested = scale.zoom * (Number.isFinite(factor) && factor > 0 ? factor : 1);
+  const zoom = Math.min(bounds.max, Math.max(bounds.min, requested));
+  return { zoom, x: anchor.x - px / zoom, y: anchor.y - py / zoom };
+}
+function fitToBounds(bounds, widthPx, heightPx, zoomBounds = DEFAULT_GRAPH_ZOOM, paddingPx = 40) {
+  if (!bounds || bounds.width <= 0 || bounds.height <= 0) return { zoom: 1, x: 0, y: 0 };
+  const usableW = Math.max(1, widthPx - paddingPx * 2);
+  const usableH = Math.max(1, heightPx - paddingPx * 2);
+  const zoom = Math.min(
+    zoomBounds.max,
+    Math.max(zoomBounds.min, Math.min(usableW / bounds.width, usableH / bounds.height))
+  );
+  const x = bounds.x + bounds.width / 2 - widthPx / zoom / 2;
+  const y = bounds.y + bounds.height / 2 - heightPx / zoom / 2;
+  return { zoom, x, y };
+}
+function graphBounds(nodes) {
+  if (nodes.length === 0) return null;
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (const node of nodes) {
+    if (!Number.isFinite(node.x) || !Number.isFinite(node.y)) continue;
+    minX = Math.min(minX, node.x);
+    minY = Math.min(minY, node.y);
+    maxX = Math.max(maxX, node.x + Math.max(1, node.width));
+    maxY = Math.max(maxY, node.y + Math.max(1, node.height));
+  }
+  if (!Number.isFinite(minX)) return null;
+  return { x: minX, y: minY, width: Math.max(1, maxX - minX), height: Math.max(1, maxY - minY) };
+}
+
+// src/edit/nodegraph/types.ts
+function portRefId(ref) {
+  return `${ref.nodeId}${ref.portId}`;
+}
+function edgeKey(edge) {
+  return `${edge.fromNodeId}${edge.fromPortId}${edge.toNodeId}${edge.toPortId}`;
+}
+function findPort(node, portId) {
+  return node.inputs.find((p) => p.id === portId) ?? node.outputs.find((p) => p.id === portId) ?? null;
+}
+function portHasRoom(port, existingCount) {
+  if (port.multiple !== void 0) return port.multiple || existingCount === 0;
+  return port.direction === "out" ? true : existingCount === 0;
+}
+function nodeBounds(node) {
+  return { x: node.x, y: node.y, width: Math.max(1, node.width), height: Math.max(1, node.height) };
+}
+function boxesIntersect(a, b) {
+  return a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
+}
+
+// src/edit/nodegraph/spatial.ts
+var XenoNodeIndex = class {
+  cellSize;
+  cells = /* @__PURE__ */ new Map();
+  all;
+  constructor(nodes) {
+    this.all = nodes;
+    this.cellSize = chooseCellSize(nodes);
+    for (const node of nodes) {
+      const x0 = Math.floor(node.x / this.cellSize);
+      const y0 = Math.floor(node.y / this.cellSize);
+      const x1 = Math.floor((node.x + Math.max(1, node.width)) / this.cellSize);
+      const y1 = Math.floor((node.y + Math.max(1, node.height)) / this.cellSize);
+      for (let cx = x0; cx <= x1; cx += 1) {
+        for (let cy = y0; cy <= y1; cy += 1) {
+          const key = `${cx},${cy}`;
+          const bucket = this.cells.get(key);
+          if (bucket) bucket.push(node);
+          else this.cells.set(key, [node]);
+        }
+      }
+    }
+  }
+  /** Bucket size, for tests. */
+  get bucketSize() {
+    return this.cellSize;
+  }
+  /**
+   * Nodes intersecting a box.
+   *
+   * @param box - The query rectangle in graph space.
+   * @returns Matching nodes, each at most once.
+   */
+  query(box) {
+    const x0 = Math.floor(box.x / this.cellSize);
+    const y0 = Math.floor(box.y / this.cellSize);
+    const x1 = Math.floor((box.x + box.width) / this.cellSize);
+    const y1 = Math.floor((box.y + box.height) / this.cellSize);
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (let cx = x0; cx <= x1; cx += 1) {
+      for (let cy = y0; cy <= y1; cy += 1) {
+        for (const node of this.cells.get(`${cx},${cy}`) ?? []) {
+          if (seen.has(node.id)) continue;
+          seen.add(node.id);
+          if (boxesIntersect(node, { ...box, width: Math.max(0, box.width), height: Math.max(0, box.height) })) {
+            out.push(node);
+          }
+        }
+      }
+    }
+    return out;
+  }
+  /** The topmost node containing a point, or `null`. */
+  hit(x, y) {
+    const candidates = this.query({ x, y, width: 1e-3, height: 1e-3 });
+    if (candidates.length === 0) return null;
+    let best = null;
+    for (const node of candidates) {
+      if (x >= node.x && x <= node.x + node.width && y >= node.y && y <= node.y + node.height) {
+        if (!best || this.all.indexOf(node) > this.all.indexOf(best)) best = node;
+      }
+    }
+    return best;
+  }
+};
+function chooseCellSize(nodes) {
+  if (nodes.length === 0) return 256;
+  const sizes = [];
+  for (const node of nodes) {
+    const size = Math.max(node.width || 1, node.height || 1);
+    if (Number.isFinite(size) && size > 0) sizes.push(size);
+  }
+  if (sizes.length === 0) return 256;
+  sizes.sort((a, b) => a - b);
+  const median = sizes[Math.floor(sizes.length / 2)];
+  return Math.max(32, Math.min(4096, median * 2));
+}
+function edgeBounds(from, to, slack = 64) {
+  const x = Math.min(from.x, to.x) - slack;
+  const y = Math.min(from.y, to.y) - slack;
+  return {
+    x,
+    y,
+    width: Math.abs(to.x - from.x) + slack * 2,
+    height: Math.abs(to.y - from.y) + slack * 2
+  };
+}
+function visibleEdges(edges, portPosition, viewport) {
+  const out = [];
+  for (const edge of edges) {
+    const from = portPosition(edge.fromNodeId, edge.fromPortId);
+    const to = portPosition(edge.toNodeId, edge.toPortId);
+    if (!from || !to) continue;
+    if (!boxesIntersect(edgeBounds(from, to), viewport)) continue;
+    out.push({ edge, from, to });
+  }
+  return out;
+}
+function edgePath(from, to) {
+  const dx = Math.abs(to.x - from.x);
+  const reach = Math.max(40, Math.min(dx * 0.6, 240));
+  return `M${from.x},${from.y} C${from.x + reach},${from.y} ${to.x - reach},${to.y} ${to.x},${to.y}`;
+}
+function distanceToEdge(point, from, to, samples = 16) {
+  const dx = Math.abs(to.x - from.x);
+  const reach = Math.max(40, Math.min(dx * 0.6, 240));
+  const c1 = { x: from.x + reach, y: from.y };
+  const c2 = { x: to.x - reach, y: to.y };
+  let best = Number.POSITIVE_INFINITY;
+  for (let i = 0; i <= samples; i += 1) {
+    const t = i / samples;
+    const mt = 1 - t;
+    const x = mt * mt * mt * from.x + 3 * mt * mt * t * c1.x + 3 * mt * t * t * c2.x + t * t * t * to.x;
+    const y = mt * mt * mt * from.y + 3 * mt * mt * t * c1.y + 3 * mt * t * t * c2.y + t * t * t * to.y;
+    best = Math.min(best, Math.hypot(x - point.x, y - point.y));
+  }
+  return best;
+}
+
+export {
+  DEFAULT_CURVE_ZOOM,
+  XenoCurveScale,
+  zoomTimeAboutCursor,
+  zoomValueAboutCursor,
+  wheelZoomFactor,
+  fitValueRange,
+  DEFAULT_GRAPH_ZOOM,
+  XenoGraphScale,
+  zoomAboutCursor,
+  fitToBounds,
+  graphBounds,
+  portRefId,
+  edgeKey,
+  findPort,
+  portHasRoom,
+  nodeBounds,
+  boxesIntersect,
+  XenoNodeIndex,
+  edgeBounds,
+  visibleEdges,
+  edgePath,
+  distanceToEdge
+};