@aethervtt/shard-vector 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Dias
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,3 @@
-# Temporary Holding Version
+# @aethervtt/shard-vector
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Part of [Shard](https://github.com/aethervtt/shard), a WebGPU-first 2D/3D game engine in TypeScript. See the repository for documentation.

package/dist/coverage.d.ts

@@ -0,0 +1,52 @@
+export type Ring = [number, number][];
+export type CoverageShape = {
+    kind: 'rect';
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+} | {
+    kind: 'polygon';
+    outer: Ring;
+    holes?: Ring[];
+} | {
+    kind: 'multipolygon';
+    polygons: {
+        outer: Ring;
+        holes?: Ring[];
+    }[];
+} | {
+    kind: 'brush';
+    points: Ring;
+    radius: number;
+};
+export interface CoverageMesh {
+    /** x, z per vertex. */
+    positions: Float32Array;
+    /** 1 inside the shape, down to 0 at the feather's outer edge. */
+    coverage: Float32Array;
+    indices: Uint32Array;
+    /** How many of `indices` belong to the core (coverage 1); ring triangles follow them. */
+    coreIndices: number;
+}
+export interface CoverageOptions {
+    /** Width of the soft edge outside the shape, in world units. 0: a hard edge. */
+    feather: number;
+    /** Chord error allowed on arcs (round caps, corners), in world units. Default 0.01. */
+    error?: number;
+    /**
+     * Drops input points the outline doesn't need: the simplified outline stays within this distance
+     * of the given one (Douglas–Peucker). A mask of texel t loses nothing at 8 bits with t / 255.
+     * Default 0: every point kept.
+     */
+    tolerance?: number;
+}
+/** Checks a region shape (from a host or a file) and returns it typed. */
+export declare function parseCoverageShape(value: unknown, path?: string): CoverageShape;
+/**
+ * Tessellates a region shape with its feather. Core triangles (coverage 1) come first; a stencil
+ * that takes each texel's first triangle per region makes overlaps harmless (see above).
+ */
+export declare function featheredCoverage(shape: CoverageShape, options: CoverageOptions): CoverageMesh;
+/** The bounds of a shape with its feather: [minX, minZ, maxX, maxZ]. */
+export declare function coverageBounds(shape: CoverageShape, feather: number): [number, number, number, number];

package/dist/coverage.js

@@ -0,0 +1,423 @@
+import { polygon, ShardError } from "@aethervtt/shard-core";
+const MITER_LIMIT = 4;
+class Builder {
+  positions = [];
+  coverage = [];
+  core = [];
+  ring = [];
+  vertex(x, z, c) {
+    this.positions.push(x, z);
+    this.coverage.push(c);
+    return this.coverage.length - 1;
+  }
+  finish() {
+    const indices = new Uint32Array(this.core.length + this.ring.length);
+    indices.set(this.core);
+    indices.set(this.ring, this.core.length);
+    return {
+      positions: new Float32Array(this.positions),
+      coverage: new Float32Array(this.coverage),
+      indices,
+      coreIndices: this.core.length
+    };
+  }
+}
+function invalid(message, path) {
+  return new ShardError("vector/invalid-geometry", message, {
+    path,
+    hint: "A region shape is { kind: 'rect' | 'polygon' | 'multipolygon' | 'brush', ... } in world (x, z)."
+  });
+}
+function finite(value, path, min = -Infinity) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min)
+    throw invalid(min === 0 ? "Expected a non-negative number" : "Expected a number", path);
+  return value;
+}
+function ring(value, path, min) {
+  if (!Array.isArray(value) || value.length < min)
+    throw invalid(`Expected at least ${min} points`, path);
+  for (let i = 0; i < value.length; i++) {
+    const p = value[i];
+    if (!Array.isArray(p) || p.length !== 2)
+      throw invalid("Expected a point [x, z]", `${path}/${i}`);
+    finite(p[0], `${path}/${i}/0`);
+    finite(p[1], `${path}/${i}/1`);
+  }
+  return value;
+}
+function polygonOf(value, path) {
+  if (!value || typeof value !== "object") throw invalid("Expected { outer, holes }", path);
+  const p = value;
+  const holes = p.holes === void 0 ? [] : p.holes;
+  if (!Array.isArray(holes)) throw invalid("Expected a list of holes", `${path}/holes`);
+  return {
+    outer: ring(p.outer, `${path}/outer`, 3),
+    holes: holes.map((h, i) => ring(h, `${path}/holes/${i}`, 3))
+  };
+}
+function parseCoverageShape(value, path = "/shape") {
+  if (!value || typeof value !== "object") throw invalid("Expected a shape object", path);
+  const s = value;
+  switch (s.kind) {
+    case "rect":
+      return {
+        kind: "rect",
+        x: finite(s.x, `${path}/x`),
+        y: finite(s.y, `${path}/y`),
+        w: finite(s.w, `${path}/w`, 0),
+        h: finite(s.h, `${path}/h`, 0)
+      };
+    case "polygon":
+      return { kind: "polygon", ...polygonOf(s, path) };
+    case "multipolygon": {
+      if (!Array.isArray(s.polygons))
+        throw invalid("Expected a list of polygons", `${path}/polygons`);
+      return {
+        kind: "multipolygon",
+        polygons: s.polygons.map((p, i) => polygonOf(p, `${path}/polygons/${i}`))
+      };
+    }
+    case "brush":
+      return {
+        kind: "brush",
+        points: ring(s.points, `${path}/points`, 1),
+        radius: finite(s.radius, `${path}/radius`, 0)
+      };
+    default:
+      throw invalid(`Unknown shape kind ${JSON.stringify(s.kind)}`, `${path}/kind`);
+  }
+}
+function arcSteps(r, angle, error) {
+  if (angle <= 1e-9) return 0;
+  if (r <= error) return Math.max(1, Math.ceil(angle / (Math.PI / 2)));
+  const step = 2 * Math.acos(Math.max(-1, 1 - error / r));
+  return Math.max(1, Math.min(512, Math.ceil(angle / step)));
+}
+function area(r) {
+  let a = 0;
+  for (let i = 0, j = r.length - 1; i < r.length; j = i++)
+    a += r[j][0] * r[i][1] - r[i][0] * r[j][1];
+  return a / 2;
+}
+function clean(r, closed, tolerance) {
+  const out = [];
+  for (const p of r) {
+    const last = out[out.length - 1];
+    if (!last || last[0] !== p[0] || last[1] !== p[1]) out.push(p);
+  }
+  if (closed && out.length > 1) {
+    const a = out[0];
+    const z = out[out.length - 1];
+    if (a[0] === z[0] && a[1] === z[1]) out.pop();
+  }
+  return tolerance > 0 ? simplify(out, closed, tolerance) : out;
+}
+function simplify(r, closed, tolerance) {
+  const n = r.length;
+  if (n <= (closed ? 4 : 2)) return r;
+  const keep = new Uint8Array(n);
+  const t2 = tolerance * tolerance;
+  const spans = [];
+  keep[0] = 1;
+  if (closed) {
+    let far = 1;
+    let best = -1;
+    for (let i = 1; i < n; i++) {
+      const dx = r[i][0] - r[0][0];
+      const dz = r[i][1] - r[0][1];
+      const d = dx * dx + dz * dz;
+      if (d > best) {
+        best = d;
+        far = i;
+      }
+    }
+    keep[far] = 1;
+    spans.push(0, far, far, n);
+  } else {
+    keep[n - 1] = 1;
+    spans.push(0, n - 1);
+  }
+  while (spans.length > 0) {
+    const end = spans.pop();
+    const start = spans.pop();
+    if (end - start < 2) continue;
+    const a = r[start];
+    const b = r[end % n];
+    const cx = b[0] - a[0];
+    const cz = b[1] - a[1];
+    const len2 = cx * cx + cz * cz;
+    let worst = -1;
+    let at = -1;
+    for (let i = start + 1; i < end; i++) {
+      const p = r[i];
+      let dx = p[0] - a[0];
+      let dz = p[1] - a[1];
+      if (len2 > 0) {
+        const t = Math.max(0, Math.min(1, (dx * cx + dz * cz) / len2));
+        dx -= t * cx;
+        dz -= t * cz;
+      }
+      const d = dx * dx + dz * dz;
+      if (d > worst) {
+        worst = d;
+        at = i;
+      }
+    }
+    if (worst > t2) {
+      keep[at] = 1;
+      spans.push(start, at, at, end);
+    }
+  }
+  const out = [];
+  for (let i = 0; i < n; i++) if (keep[i]) out.push(r[i]);
+  return out;
+}
+function polygonCoverage(b, outer, holes, feather, error, tolerance) {
+  const rings = [outer, ...holes].map((r, i) => {
+    const c = clean(r, true, tolerance);
+    const ccw = area(c) > 0;
+    return i === 0 === ccw ? c : [...c].reverse();
+  }).filter((r) => r.length >= 3);
+  if (rings.length === 0 || rings[0].length < 3) return;
+  let total = 0;
+  for (const r of rings) total += r.length;
+  const flat = new Float64Array(total * 2);
+  const starts = [];
+  let k = 0;
+  const firstVertex = b.coverage.length;
+  for (let i = 0; i < rings.length; i++) {
+    if (i > 0) starts.push(k);
+    for (const [x, z] of rings[i]) {
+      flat[k * 2] = x;
+      flat[k * 2 + 1] = z;
+      b.vertex(x, z, 1);
+      k++;
+    }
+  }
+  const tris = polygon.triangulate(flat, starts);
+  for (let i = 0; i < tris.length; i++) b.core.push(firstVertex + tris[i]);
+  if (feather <= 0) return;
+  let base = firstVertex;
+  for (const r of rings) {
+    featherRing(b, r, base, feather, error);
+    base += r.length;
+  }
+}
+function featherRing(b, r, first, feather, error) {
+  const n = r.length;
+  const nx = new Float64Array(n);
+  const nz = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    const a = r[i];
+    const c = r[(i + 1) % n];
+    const dx = c[0] - a[0];
+    const dz = c[1] - a[1];
+    const len = Math.sqrt(dx * dx + dz * dz) || 1;
+    nx[i] = dz / len;
+    nz[i] = -dx / len;
+  }
+  const endOf = new Int32Array(n);
+  const startOf = new Int32Array(n);
+  for (let i = 0; i < n; i++) {
+    const p = r[i];
+    const e0 = (i - 1 + n) % n;
+    const e1 = i;
+    const turn = nx[e0] * nz[e1] - nz[e0] * nx[e1];
+    const convex = turn > 0;
+    if (convex) {
+      const o0 = b.vertex(p[0] + nx[e0] * feather, p[1] + nz[e0] * feather, 0);
+      const o1 = b.vertex(p[0] + nx[e1] * feather, p[1] + nz[e1] * feather, 0);
+      endOf[i] = o0;
+      startOf[i] = o1;
+      const a0 = Math.atan2(nz[e0], nx[e0]);
+      let a1 = Math.atan2(nz[e1], nx[e1]);
+      let da = a1 - a0;
+      while (da > Math.PI) da -= Math.PI * 2;
+      while (da < -Math.PI) da += Math.PI * 2;
+      a1 = a0 + da;
+      const steps = arcSteps(feather, Math.abs(da), error);
+      let prev = o0;
+      for (let s = 1; s <= steps; s++) {
+        const next = s === steps ? o1 : b.vertex(
+          p[0] + Math.cos(a0 + da * s / steps) * feather,
+          p[1] + Math.sin(a0 + da * s / steps) * feather,
+          0
+        );
+        b.ring.push(first + i, prev, next);
+        prev = next;
+      }
+    } else {
+      const mx = nx[e0] + nx[e1];
+      const mz = nz[e0] + nz[e1];
+      const ml = Math.sqrt(mx * mx + mz * mz);
+      let ox = nx[e1];
+      let oz = nz[e1];
+      if (ml > 1e-9) {
+        const ux = mx / ml;
+        const uz = mz / ml;
+        const scale = Math.min(MITER_LIMIT, 1 / Math.max(1e-6, ux * nx[e1] + uz * nz[e1]));
+        ox = ux * scale;
+        oz = uz * scale;
+      }
+      const m = b.vertex(p[0] + ox * feather, p[1] + oz * feather, 0);
+      endOf[i] = m;
+      startOf[i] = m;
+    }
+  }
+  for (let i = 0; i < n; i++) {
+    const j = (i + 1) % n;
+    const pi = first + i;
+    const pj = first + j;
+    b.ring.push(pi, pj, endOf[j], pi, endOf[j], startOf[i]);
+  }
+}
+function disk(b, c, radius, feather, error) {
+  arc(b, c, radius, feather, 0, Math.PI * 2, error);
+}
+function arc(b, c, radius, feather, a0, a1, error) {
+  const span = a1 - a0;
+  const steps = Math.max(1, arcSteps(radius + feather, Math.abs(span), error));
+  const centre = b.vertex(c[0], c[1], 1);
+  let prevIn = -1;
+  let prevOut = -1;
+  for (let s = 0; s <= steps; s++) {
+    const a = a0 + span * s / steps;
+    const cx = Math.cos(a);
+    const cz = Math.sin(a);
+    const inner = b.vertex(c[0] + cx * radius, c[1] + cz * radius, 1);
+    const outer = feather > 0 ? b.vertex(c[0] + cx * (radius + feather), c[1] + cz * (radius + feather), 0) : -1;
+    if (s > 0) {
+      if (radius > 0) b.core.push(centre, prevIn, inner);
+      if (feather > 0) b.ring.push(prevIn, inner, outer, prevIn, outer, prevOut);
+    }
+    prevIn = inner;
+    prevOut = outer;
+  }
+}
+function brushCoverage(b, pts, radius, feather, error, tolerance) {
+  const path = clean(pts, false, tolerance);
+  if (path.length === 0) return;
+  if (path.length === 1) {
+    disk(b, path[0], radius, feather, error);
+    return;
+  }
+  const n = path.length;
+  const segments = n - 1;
+  const nx = new Float64Array(segments);
+  const nz = new Float64Array(segments);
+  for (let s = 0; s < segments; s++) {
+    const a = path[s];
+    const c = path[s + 1];
+    const dx = c[0] - a[0];
+    const dz = c[1] - a[1];
+    const len = Math.sqrt(dx * dx + dz * dz) || 1;
+    nx[s] = -dz / len;
+    nz[s] = dx / len;
+  }
+  const r = radius;
+  const f = feather;
+  for (let s = 0; s < segments; s++) {
+    const a = path[s];
+    const c = path[s + 1];
+    const ox = nx[s];
+    const oz = nz[s];
+    const al = b.vertex(a[0] + ox * r, a[1] + oz * r, 1);
+    const ar = b.vertex(a[0] - ox * r, a[1] - oz * r, 1);
+    const cl = b.vertex(c[0] + ox * r, c[1] + oz * r, 1);
+    const cr = b.vertex(c[0] - ox * r, c[1] - oz * r, 1);
+    b.core.push(al, ar, cl, ar, cr, cl);
+    if (f > 0) {
+      const alo = b.vertex(a[0] + ox * (r + f), a[1] + oz * (r + f), 0);
+      const clo = b.vertex(c[0] + ox * (r + f), c[1] + oz * (r + f), 0);
+      const aro = b.vertex(a[0] - ox * (r + f), a[1] - oz * (r + f), 0);
+      const cro = b.vertex(c[0] - ox * (r + f), c[1] - oz * (r + f), 0);
+      b.ring.push(al, cl, clo, al, clo, alo, ar, cr, cro, ar, cro, aro);
+    }
+  }
+  for (let v = 1; v < n - 1; v++) {
+    const s0 = v - 1;
+    const s1 = v;
+    const a0 = Math.atan2(nz[s0], nx[s0]);
+    let da = Math.atan2(nz[s1], nx[s1]) - a0;
+    while (da > Math.PI) da -= Math.PI * 2;
+    while (da < -Math.PI) da += Math.PI * 2;
+    if (Math.abs(da) < 1e-9) continue;
+    const start = da > 0 ? a0 + Math.PI : a0;
+    arc(b, path[v], r, f, start, start + da, error);
+  }
+  const first = Math.atan2(nz[0], nx[0]);
+  arc(b, path[0], r, f, first, first + Math.PI, error);
+  const last = Math.atan2(nz[segments - 1], nx[segments - 1]);
+  arc(b, path[n - 1], r, f, last + Math.PI, last + Math.PI * 2, error);
+}
+function featheredCoverage(shape, options) {
+  const feather = Math.max(0, options.feather);
+  const error = options.error ?? 0.01;
+  const tolerance = Math.max(0, options.tolerance ?? 0);
+  const b = new Builder();
+  switch (shape.kind) {
+    case "rect":
+      if (shape.w > 0 && shape.h > 0) {
+        const { x, y, w, h } = shape;
+        polygonCoverage(
+          b,
+          [
+            [x, y],
+            [x + w, y],
+            [x + w, y + h],
+            [x, y + h]
+          ],
+          [],
+          feather,
+          error,
+          0
+        );
+      }
+      break;
+    case "polygon":
+      polygonCoverage(b, shape.outer, shape.holes ?? [], feather, error, tolerance);
+      break;
+    case "multipolygon":
+      for (const p of shape.polygons)
+        polygonCoverage(b, p.outer, p.holes ?? [], feather, error, tolerance);
+      break;
+    case "brush":
+      brushCoverage(b, shape.points, shape.radius, feather, error, tolerance);
+      break;
+  }
+  return b.finish();
+}
+function coverageBounds(shape, feather) {
+  let minX = Infinity;
+  let minZ = Infinity;
+  let maxX = -Infinity;
+  let maxZ = -Infinity;
+  const add = (x, z, pad) => {
+    if (x - pad < minX) minX = x - pad;
+    if (z - pad < minZ) minZ = z - pad;
+    if (x + pad > maxX) maxX = x + pad;
+    if (z + pad > maxZ) maxZ = z + pad;
+  };
+  switch (shape.kind) {
+    case "rect":
+      add(shape.x, shape.y, feather);
+      add(shape.x + shape.w, shape.y + shape.h, feather);
+      break;
+    case "polygon":
+      for (const p of shape.outer) add(p[0], p[1], feather * MITER_LIMIT);
+      break;
+    case "multipolygon":
+      for (const poly of shape.polygons)
+        for (const p of poly.outer) add(p[0], p[1], feather * MITER_LIMIT);
+      break;
+    case "brush":
+      for (const p of shape.points) add(p[0], p[1], shape.radius + feather);
+      break;
+  }
+  return [minX, minZ, maxX, maxZ];
+}
+export {
+  coverageBounds,
+  featheredCoverage,
+  parseCoverageShape
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { type CoverageMesh, type CoverageOptions, type CoverageShape, coverageBounds, featheredCoverage, parseCoverageShape, type Ring, } from './coverage.js';
+export { vectorPlugin } from './plugin.js';
+export { STROKE_UNITS, syncShapes, VECTOR_SHADERS, VectorMaterial, VectorShape, VectorState, type VectorStateValue, } from './shape.js';
+export { meshArea, parseGeometry, type StrokeUnits, type TessellateOptions, tessellate, type VectorGeometry, type VectorMesh, type VectorStyle, } from './tessellate.js';

package/dist/index.js

@@ -0,0 +1,34 @@
+import {
+  coverageBounds,
+  featheredCoverage,
+  parseCoverageShape
+} from "./coverage.js";
+import { vectorPlugin } from "./plugin.js";
+import {
+  STROKE_UNITS,
+  syncShapes,
+  VECTOR_SHADERS,
+  VectorMaterial,
+  VectorShape,
+  VectorState
+} from "./shape.js";
+import {
+  meshArea,
+  parseGeometry,
+  tessellate
+} from "./tessellate.js";
+export {
+  STROKE_UNITS,
+  VECTOR_SHADERS,
+  VectorMaterial,
+  VectorShape,
+  VectorState,
+  coverageBounds,
+  featheredCoverage,
+  meshArea,
+  parseCoverageShape,
+  parseGeometry,
+  syncShapes,
+  tessellate,
+  vectorPlugin
+};

package/dist/plugin.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Vector drawings (0057): pen, line, rect, ellipse, cone and polygon shapes with stroke and
+ * fill, in the drawings band. Needs `forwardPlugin` (render/forward).
+ */
+export declare const vectorPlugin: import("@aethervtt/shard-runtime").Plugin;

package/dist/plugin.js

@@ -0,0 +1,28 @@
+import { PostUpdate } from "@aethervtt/shard-core";
+import { registerShaders, Shaders } from "@aethervtt/shard-render";
+import { definePlugin } from "@aethervtt/shard-runtime";
+import { TransformSystems } from "@aethervtt/shard-transform";
+import {
+  observeShapeRemovals,
+  syncShapes,
+  VECTOR_SHADERS,
+  VectorMaterial,
+  VectorShape,
+  VectorState
+} from "./shape.js";
+const vectorPlugin = definePlugin({
+  name: "vector",
+  dependencies: ["render/forward", "core/transform"],
+  provides: [VectorShape, VectorMaterial, VectorState],
+  build(app) {
+    app.world.initResource(VectorState);
+    observeShapeRemovals(app.world);
+    app.addSystems(PostUpdate, syncShapes.before(TransformSystems));
+  },
+  ready(app) {
+    registerShaders(app.world.resource(Shaders), VECTOR_SHADERS);
+  }
+});
+export {
+  vectorPlugin
+};

package/dist/shape.d.ts

@@ -0,0 +1,41 @@
+import { type AssetRef, type Entity, type World } from '@aethervtt/shard-core';
+export declare const STROKE_UNITS: readonly ['world', 'css-px'];
+export declare const VectorShape: import("@aethervtt/shard-core").ComponentDef<{
+    readonly geometry: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").JsonValue, "object">;
+    readonly stroke: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
+    readonly strokeWidth: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly strokeUnits: import("@aethervtt/shard-core").FieldType<"css-px" | "world", "u8">;
+    readonly fill: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
+    readonly fillOpacity: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly rev: import("@aethervtt/shard-core").FieldType<number, "u32">;
+}>;
+export declare const VectorMaterial: import("@aethervtt/shard-render").MaterialType;
+export declare const VECTOR_SHADERS: Record<string, string>;
+interface ShapeRecord {
+    /** Absent while the shape has nothing to draw. */
+    mesh: AssetRef<'Mesh'> | undefined;
+    material: AssetRef<'Material'>;
+    rev: number;
+    strokeWidth: number;
+    strokeUnits: string;
+    filled: boolean;
+}
+export interface VectorStateValue {
+    shapes: Map<Entity, ShapeRecord>;
+    removed: Entity[];
+    /** Rebuilds since start (tessellations). */
+    rebuilds: number;
+    /** The densest zoom, CSS px per world unit: curves are fine to half a pixel there. */
+    pixelsPerUnit: number;
+}
+export declare const VectorState: import("@aethervtt/shard-core").ResourceDef<VectorStateValue>;
+/**
+ * Tessellates changed VectorShapes whose rev (or stroke width, units, or fill) changed, and keeps
+ * their material's colors current. Adds Mesh3d, MeshMaterial and a drawings-band GroundLayer.
+ */
+export declare const syncShapes: import("@aethervtt/shard-core").SystemDef<{
+    q: import("@aethervtt/shard-core").Query;
+    changed: Entity[];
+}>;
+export declare function observeShapeRemovals(world: World): void;
+export {};

package/dist/shape.js

@@ -0,0 +1,216 @@
+import {
+  defineComponent,
+  defineResource,
+  defineSystem,
+  onRemove,
+  ShardError,
+  t
+} from "@aethervtt/shard-core";
+import { Mesh } from "@aethervtt/shard-mesh";
+import {
+  defineMaterial,
+  GpuAssetsResource,
+  GROUND_BANDS,
+  GroundLayer,
+  MaterialAsset,
+  Materials,
+  Mesh3d,
+  Meshes,
+  MeshMaterial,
+  NotShadowCaster
+} from "@aethervtt/shard-render";
+import { LogResource } from "@aethervtt/shard-runtime";
+import { parseGeometry, tessellate } from "./tessellate.js";
+const STROKE_UNITS = ["world", "css-px"];
+const VectorShape = defineComponent(
+  "vector/VectorShape",
+  {
+    geometry: t.json({
+      default: { kind: "rect", width: 1, height: 1 },
+      description: "Local (x, z) shape: { kind: 'pen', points } | { kind: 'line', from, to } | { kind: 'rect', width, height } (from the origin) | { kind: 'ellipse', rx, ry } (centred) | { kind: 'cone', length, angle } (apex at the origin, along +x, angle in degrees) | { kind: 'polygon', outer, holes }."
+    }),
+    stroke: t.color({
+      default: [0, 0, 0, 1],
+      description: "Stroke color (linear), alpha included."
+    }),
+    strokeWidth: t.f32({
+      default: 2,
+      min: 0,
+      description: "Stroke width, in strokeUnits. 0: none."
+    }),
+    strokeUnits: t.enum(STROKE_UNITS, {
+      description: "world: scales with the map. css-px: the same on screen at any zoom (widened per view, never rebuilt)."
+    }),
+    fill: t.color({
+      default: [1, 1, 1, 1],
+      description: "Fill color (linear), for closed shapes."
+    }),
+    fillOpacity: t.f32({ min: 0, max: 1, description: "Fill opacity. 0: no fill." }),
+    rev: t.u32({
+      description: "Revision of the geometry and stroke: the mesh is rebuilt only when it changes."
+    })
+  },
+  {
+    description: "A vector drawing on the table (0057): stroke and fill, tessellated once per rev, drawn in the drawings band (30) unless it has its own GroundLayer."
+  }
+);
+const VectorMaterial = defineMaterial("vector/VectorMaterial", {
+  extends: "none",
+  blend: "premultiplied",
+  fields: {
+    stroke: t.color({ default: [0, 0, 0, 1] }),
+    fill: t.color({ default: [1, 1, 1, 1] })
+  },
+  shader: "vector::shape",
+  description: "A vector shape's stroke and fill colors (0057). One per VectorShape."
+});
+const VECTOR_SHADERS = {
+  "vector::shape": `
+import shard::pbr::types::VertexOutput;
+import shard::view::view;
+import shard::mesh::{ vertex_tangent, vertex_world };
+import material::vector_material::VectorMaterial;
+
+/** CSS-pixel strokes: offset (tangent xyz) \xD7 half width in CSS px (w) \xD7 this view's pixel size. */
+override fn vertex_position(position: vec3f, normal: vec3f, uv: vec2f) -> vec3f {
+  let t = vertex_tangent();
+  if (t.w <= 0.0) { return position; }
+  let world = vertex_world(position);
+  var per_px = view.pixelScale.x * view.pixelScale.y;
+  if (view.pixelScale.z < 0.5) { per_px *= max(-(view.view * vec4f(world, 1.0)).z, 1e-4); }
+  // Offsets are in world units; undo the instance's (uniform) scale.
+  let scale = length(vertex_world(position + vec3f(1.0, 0.0, 0.0)) - world);
+  return position + t.xyz * (t.w * per_px / max(scale, 1e-6));
+}
+
+override fn shade(in: VertexOutput) -> vec4f {
+  let c = select(VectorMaterial.fill, VectorMaterial.stroke, in.uv.x > 0.5);
+  if (c.a <= 0.0) { discard; }
+  // Display-referred: the scene's exposure doesn't dim a drawing.
+  return vec4f(c.rgb * c.a / view.exposure, c.a);
+}`
+};
+const VectorState = defineResource("vector/State", {
+  description: "Each VectorShape's mesh and material, and how many rebuilds ran.",
+  init: () => ({ shapes: /* @__PURE__ */ new Map(), removed: [], rebuilds: 0, pixelsPerUnit: 256 })
+});
+function materialValues(v) {
+  return {
+    stroke: [...v.stroke],
+    fill: [v.fill[0], v.fill[1], v.fill[2], v.fill[3] * v.fillOpacity]
+  };
+}
+const syncShapes = defineSystem({
+  name: "vector/sync",
+  description: "Rebuilds VectorShape meshes when their rev changes; keeps colors current.",
+  setup: (world) => ({ q: world.query({ with: [VectorShape] }), changed: [] }),
+  run: ({ q, changed }, world, ctx) => {
+    const state = world.resource(VectorState);
+    if (state.removed.length > 0) {
+      for (const e of state.removed) dropShape(world, state, e);
+      state.removed.length = 0;
+    }
+    const since = ctx.lastRunTick;
+    changed.length = 0;
+    for (const table of q.tables) {
+      if (table.lastChanged(VectorShape) <= since) continue;
+      const ticks = table.changedTicks(VectorShape);
+      for (let row = 0; row < table.count; row++)
+        if (ticks[row] > since) changed.push(table.entities[row]);
+    }
+    for (const e of changed) updateShape(world, state, e);
+  }
+});
+function updateShape(world, state, e) {
+  const v = world.get(e, VectorShape);
+  const filled = v.fillOpacity > 0 && v.fill[3] > 0;
+  let rec = state.shapes.get(e);
+  const needsMesh = !rec || rec.rev !== v.rev || rec.strokeWidth !== v.strokeWidth || rec.strokeUnits !== v.strokeUnits || rec.filled !== filled;
+  let data;
+  if (needsMesh) {
+    try {
+      const geometry = parseGeometry(v.geometry);
+      data = tessellate(
+        geometry,
+        { strokeWidth: v.strokeWidth, strokeUnits: v.strokeUnits, fill: filled },
+        { pixelsPerUnit: state.pixelsPerUnit }
+      );
+      state.rebuilds++;
+    } catch (err) {
+      if (!(err instanceof ShardError)) throw err;
+      world.tryResource(LogResource)?.log("warn", `VectorShape ${e}: ${err.message}`, {
+        code: err.code,
+        path: err.path,
+        hint: err.hint
+      });
+      return;
+    }
+  }
+  const materials = world.resource(Materials);
+  if (!rec) {
+    const material = materials.add(
+      new MaterialAsset(materialValues(v), VectorMaterial),
+      `vector:shape/${e}`
+    );
+    rec = {
+      mesh: void 0,
+      material,
+      rev: v.rev,
+      strokeWidth: v.strokeWidth,
+      strokeUnits: v.strokeUnits,
+      filled
+    };
+    state.shapes.set(e, rec);
+    world.add(e, MeshMaterial, { material });
+    if (!world.has(e, NotShadowCaster)) world.add(e, NotShadowCaster);
+    if (!world.has(e, GroundLayer)) world.add(e, GroundLayer, { band: GROUND_BANDS.drawings });
+  } else materials.get(rec.material)?.set(materialValues(v));
+  if (data) {
+    if (data.indices.length === 0) {
+      if (world.has(e, Mesh3d)) world.remove(e, Mesh3d);
+    } else {
+      const meshes = world.resource(Meshes);
+      if (rec.mesh) meshes.get(rec.mesh)?.update(data);
+      else rec.mesh = meshes.add(Mesh.create(data), `vector:shape/${e}`);
+      if (!world.has(e, Mesh3d)) world.add(e, Mesh3d, { mesh: rec.mesh });
+    }
+  }
+  rec.rev = v.rev;
+  rec.strokeWidth = v.strokeWidth;
+  rec.strokeUnits = v.strokeUnits;
+  rec.filled = filled;
+}
+function dropShape(world, state, e) {
+  const rec = state.shapes.get(e);
+  if (!rec) return;
+  state.shapes.delete(e);
+  const meshes = world.resource(Meshes);
+  const materials = world.resource(Materials);
+  const gpu = world.tryResource(GpuAssetsResource);
+  if (rec.mesh) {
+    const mesh = meshes.get(rec.mesh);
+    if (mesh) gpu?.releaseMesh(mesh);
+    meshes.delete(rec.mesh.guid);
+  }
+  const material = materials.get(rec.material);
+  if (material) gpu?.releaseMaterial(material);
+  materials.delete(rec.material.guid);
+  if (world.isAlive(e)) {
+    if (world.has(e, Mesh3d)) world.remove(e, Mesh3d);
+    if (world.has(e, MeshMaterial)) world.remove(e, MeshMaterial);
+  }
+}
+function observeShapeRemovals(world) {
+  world.observe(onRemove(VectorShape), ({ entity, world: w }) => {
+    w.tryResource(VectorState)?.removed.push(entity);
+  });
+}
+export {
+  STROKE_UNITS,
+  VECTOR_SHADERS,
+  VectorMaterial,
+  VectorShape,
+  VectorState,
+  observeShapeRemovals,
+  syncShapes
+};

package/dist/tessellate.d.ts

@@ -0,0 +1,56 @@
+export type VectorGeometry = {
+    kind: 'pen';
+    points: [number, number][];
+} | {
+    kind: 'line';
+    from: [number, number];
+    to: [number, number];
+} | {
+    kind: 'rect';
+    width: number;
+    height: number;
+} | {
+    kind: 'ellipse';
+    rx: number;
+    ry: number;
+} | {
+    kind: 'cone';
+    length: number;
+    angle: number;
+} | {
+    kind: 'polygon';
+    outer: [number, number][];
+    holes?: [number, number][][];
+};
+export type StrokeUnits = 'world' | 'css-px';
+export interface VectorStyle {
+    /** Stroke width: world units, or CSS pixels. 0: no stroke. */
+    strokeWidth: number;
+    strokeUnits: StrokeUnits;
+    /** Whether to fill (closed shapes only). */
+    fill: boolean;
+}
+export interface TessellateOptions {
+    /**
+     * The densest zoom, in CSS pixels per world unit: curves are subdivided to a chord error of
+     * 0.5 CSS px there. Default 256.
+     */
+    pixelsPerUnit?: number;
+}
+/** Tessellated vertex and index data (a `MeshData` for `@aethervtt/shard-mesh`). */
+export interface VectorMesh {
+    positions: Float32Array;
+    normals: Float32Array;
+    uvs: Float32Array;
+    tangents: Float32Array;
+    indices: Uint32Array;
+}
+/** Checks a geometry value (from a scene file or a host) and returns it typed. */
+export declare function parseGeometry(value: unknown, path?: string): VectorGeometry;
+/**
+ * Tessellates a shape into a mesh in its local XZ plane. Fills only closed shapes; pen strokes
+ * get round joins and caps, the rest mitred joins (butt caps on open lines).
+ */
+export declare function tessellate(geometry: VectorGeometry, style: VectorStyle, options?: TessellateOptions): VectorMesh;
+/** Area of the upward-facing triangles of a mesh (world units²): tests and stats. */
+export declare function meshArea(mesh: VectorMesh, u?: number): number;

package/dist/tessellate.js

@@ -0,0 +1,379 @@
+import { polygon, ShardError } from "@aethervtt/shard-core";
+class Builder {
+  positions;
+  uvs;
+  tangents;
+  indices;
+  vertices = 0;
+  count = 0;
+  constructor(vertices, indices) {
+    this.positions = new Float32Array(Math.max(4, vertices) * 3);
+    this.uvs = new Float32Array(Math.max(4, vertices) * 2);
+    this.tangents = new Float32Array(Math.max(4, vertices) * 4);
+    this.indices = new Uint32Array(Math.max(6, indices));
+  }
+  vertex(x, z, u, tx, tz, tw) {
+    const i = this.vertices;
+    if ((i + 1) * 3 > this.positions.length) this.grow();
+    this.positions[i * 3] = x;
+    this.positions[i * 3 + 2] = z;
+    this.uvs[i * 2] = u;
+    this.tangents[i * 4] = tx;
+    this.tangents[i * 4 + 2] = tz;
+    this.tangents[i * 4 + 3] = tw;
+    this.vertices = i + 1;
+    return i;
+  }
+  /** Where a vertex ends up: CSS-pixel strokes widen along their tangent (any scale will do). */
+  x(i) {
+    return this.positions[i * 3] + this.tangents[i * 4] * this.tangents[i * 4 + 3];
+  }
+  z(i) {
+    return this.positions[i * 3 + 2] + this.tangents[i * 4 + 2] * this.tangents[i * 4 + 3];
+  }
+  /**
+   * A triangle facing up (+y): CCW seen from above is clockwise in (x, z). CSS-pixel strokes are
+   * wound by where their vertices end up once widened, not their shared centreline.
+   */
+  triangle(a, b, c) {
+    if (this.count + 3 > this.indices.length) {
+      const next = new Uint32Array(this.indices.length * 2);
+      next.set(this.indices);
+      this.indices = next;
+    }
+    const ax = this.x(a);
+    const az = this.z(a);
+    const cross = (this.x(b) - ax) * (this.z(c) - az) - (this.x(c) - ax) * (this.z(b) - az);
+    this.indices[this.count++] = a;
+    if (cross > 0) {
+      this.indices[this.count++] = c;
+      this.indices[this.count++] = b;
+    } else {
+      this.indices[this.count++] = b;
+      this.indices[this.count++] = c;
+    }
+  }
+  grow() {
+    const n = this.positions.length / 3;
+    const p = new Float32Array(n * 6);
+    p.set(this.positions);
+    this.positions = p;
+    const u = new Float32Array(n * 4);
+    u.set(this.uvs);
+    this.uvs = u;
+    const t = new Float32Array(n * 8);
+    t.set(this.tangents);
+    this.tangents = t;
+  }
+  finish() {
+    const n = this.vertices;
+    const normals = new Float32Array(n * 3);
+    for (let i = 0; i < n; i++) normals[i * 3 + 1] = 1;
+    return {
+      positions: this.positions.slice(0, n * 3),
+      normals,
+      uvs: this.uvs.slice(0, n * 2),
+      tangents: this.tangents.slice(0, n * 4),
+      indices: this.indices.slice(0, this.count)
+    };
+  }
+}
+function invalid(message, path) {
+  return new ShardError("vector/invalid-geometry", message, {
+    path,
+    hint: "geometry is { kind: 'pen' | 'line' | 'rect' | 'ellipse' | 'cone' | 'polygon', ... } in local (x, z) units."
+  });
+}
+function point(value, path) {
+  if (!Array.isArray(value) || value.length !== 2 || !Number.isFinite(value[0]) || !Number.isFinite(value[1]))
+    throw invalid("Expected a point [x, z]", path);
+  return value;
+}
+function points(value, path, min) {
+  if (!Array.isArray(value) || value.length < min)
+    throw invalid(`Expected at least ${min} points`, path);
+  for (let i = 0; i < value.length; i++) point(value[i], `${path}/${i}`);
+  return value;
+}
+function num(value, path) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+    throw invalid("Expected a non-negative number", path);
+  return value;
+}
+function parseGeometry(value, path = "/geometry") {
+  if (!value || typeof value !== "object") throw invalid("Expected a geometry object", path);
+  const g = value;
+  switch (g.kind) {
+    case "pen":
+      return { kind: "pen", points: points(g.points, `${path}/points`, 1) };
+    case "line":
+      return { kind: "line", from: point(g.from, `${path}/from`), to: point(g.to, `${path}/to`) };
+    case "rect":
+      return {
+        kind: "rect",
+        width: num(g.width, `${path}/width`),
+        height: num(g.height, `${path}/height`)
+      };
+    case "ellipse":
+      return { kind: "ellipse", rx: num(g.rx, `${path}/rx`), ry: num(g.ry, `${path}/ry`) };
+    case "cone":
+      return {
+        kind: "cone",
+        length: num(g.length, `${path}/length`),
+        angle: num(g.angle, `${path}/angle`)
+      };
+    case "polygon": {
+      const holes = g.holes === void 0 ? [] : g.holes;
+      if (!Array.isArray(holes)) throw invalid("Expected a list of holes", `${path}/holes`);
+      return {
+        kind: "polygon",
+        outer: points(g.outer, `${path}/outer`, 3),
+        holes: holes.map((h, i) => points(h, `${path}/holes/${i}`, 3))
+      };
+    }
+    default:
+      throw invalid(`Unknown geometry kind ${JSON.stringify(g.kind)}`, `${path}/kind`);
+  }
+}
+function arcSegments(r, angle, error) {
+  if (r <= error) return Math.max(3, Math.ceil(angle / (Math.PI / 2)));
+  const step = 2 * Math.acos(1 - error / r);
+  return Math.max(3, Math.min(1024, Math.ceil(angle / step)));
+}
+function outline(g, error) {
+  switch (g.kind) {
+    case "pen":
+      return { rings: [g.points], closed: false };
+    case "line":
+      return { rings: [[g.from, g.to]], closed: false };
+    case "rect":
+      return {
+        rings: [
+          [
+            [0, 0],
+            [g.width, 0],
+            [g.width, g.height],
+            [0, g.height]
+          ]
+        ],
+        closed: true
+      };
+    case "ellipse": {
+      const n = arcSegments(Math.max(g.rx, g.ry), Math.PI * 2, error);
+      const ring = [];
+      for (let i = 0; i < n; i++) {
+        const a = i / n * Math.PI * 2;
+        ring.push([Math.cos(a) * g.rx, Math.sin(a) * g.ry]);
+      }
+      return { rings: [ring], closed: true };
+    }
+    case "cone": {
+      const half = Math.min(360, g.angle) * Math.PI / 360;
+      const n = arcSegments(g.length, half * 2, error);
+      const ring = [[0, 0]];
+      for (let i = 0; i <= n; i++) {
+        const a = -half + i / n * half * 2;
+        ring.push([Math.cos(a) * g.length, Math.sin(a) * g.length]);
+      }
+      return { rings: [ring], closed: true };
+    }
+    case "polygon":
+      return { rings: [g.outer, ...g.holes ?? []], closed: true };
+  }
+}
+function fillRings(b, rings) {
+  let total = 0;
+  for (const r of rings) total += r.length;
+  const flat = new Float64Array(total * 2);
+  const holes = [];
+  let k = 0;
+  for (let i = 0; i < rings.length; i++) {
+    if (i > 0) holes.push(k);
+    for (const [x, z] of rings[i]) {
+      flat[k * 2] = x;
+      flat[k * 2 + 1] = z;
+      k++;
+    }
+  }
+  const first = b.vertices;
+  for (let i = 0; i < total; i++) b.vertex(flat[i * 2], flat[i * 2 + 1], 0, 0, 0, 0);
+  const tris = polygon.triangulate(flat, holes);
+  for (let i = 0; i < tris.length; i += 3)
+    b.triangle(first + tris[i], first + tris[i + 1], first + tris[i + 2]);
+}
+const MITER_LIMIT = 4;
+function strokePath(b, pts, closed, half, css, round, error) {
+  const path = [];
+  for (const p of pts) {
+    const last = path[path.length - 1];
+    if (!last || last[0] !== p[0] || last[1] !== p[1]) path.push(p);
+  }
+  if (closed && path.length > 2) {
+    const a = path[0];
+    const z = path[path.length - 1];
+    if (a[0] === z[0] && a[1] === z[1]) path.pop();
+  }
+  const n = path.length;
+  const put = (x, z, ox, oz) => css ? b.vertex(x, z, 1, ox, oz, half) : b.vertex(x + ox * half, z + oz * half, 1, 0, 0, 0);
+  if (n === 1) {
+    if (round) roundDot(b, path[0], half, css, error);
+    return;
+  }
+  const segments = closed ? n : n - 1;
+  const nx = new Float64Array(segments);
+  const nz = new Float64Array(segments);
+  for (let s = 0; s < segments; s++) {
+    const a = path[s];
+    const c = path[(s + 1) % n];
+    const dx = c[0] - a[0];
+    const dz = c[1] - a[1];
+    const len = Math.sqrt(dx * dx + dz * dz) || 1;
+    nx[s] = -dz / len;
+    nz[s] = dx / len;
+  }
+  if (round) {
+    for (let s = 0; s < segments; s++) {
+      const a = path[s];
+      const c = path[(s + 1) % n];
+      const l0 = put(a[0], a[1], nx[s], nz[s]);
+      const r0 = put(a[0], a[1], -nx[s], -nz[s]);
+      const l1 = put(c[0], c[1], nx[s], nz[s]);
+      const r1 = put(c[0], c[1], -nx[s], -nz[s]);
+      b.triangle(l0, r0, l1);
+      b.triangle(r0, r1, l1);
+    }
+    const joins = closed ? n : n - 2;
+    for (let j = 0; j < joins; j++) {
+      const v = closed ? j : j + 1;
+      const s0 = (v - 1 + segments) % segments;
+      const s1 = v % segments;
+      const a0 = Math.atan2(nz[s0], nx[s0]);
+      let a1 = Math.atan2(nz[s1], nx[s1]);
+      let da = a1 - a0;
+      while (da > Math.PI) da -= Math.PI * 2;
+      while (da < -Math.PI) da += Math.PI * 2;
+      a1 = a0 + da;
+      const side = da > 0 ? -1 : 1;
+      wedge(
+        b,
+        path[v],
+        half,
+        css,
+        a0 + (side < 0 ? Math.PI : 0),
+        a1 + (side < 0 ? Math.PI : 0),
+        error
+      );
+    }
+    if (!closed) {
+      const a0 = Math.atan2(nz[0], nx[0]);
+      wedge(b, path[0], half, css, a0, a0 + Math.PI, error);
+      const e = segments - 1;
+      const a1 = Math.atan2(nz[e], nx[e]);
+      wedge(b, path[n - 1], half, css, a1 + Math.PI, a1 + Math.PI * 2, error);
+    }
+    return;
+  }
+  let firstL = -1;
+  let firstR = -1;
+  let prevL = -1;
+  let prevR = -1;
+  for (let i = 0; i < n; i++) {
+    let ox;
+    let oz;
+    const s0 = i - 1;
+    const s1 = i;
+    const has0 = closed || s0 >= 0;
+    const has1 = closed || s1 < segments;
+    if (has0 && has1) {
+      const a = (s0 + segments) % segments;
+      const c = s1 % segments;
+      const mx = nx[a] + nx[c];
+      const mz = nz[a] + nz[c];
+      const ml = Math.sqrt(mx * mx + mz * mz);
+      if (ml < 1e-9) {
+        ox = nx[c];
+        oz = nz[c];
+      } else {
+        const ux = mx / ml;
+        const uz = mz / ml;
+        const scale = Math.min(MITER_LIMIT, 1 / Math.max(1e-6, ux * nx[c] + uz * nz[c]));
+        ox = ux * scale;
+        oz = uz * scale;
+      }
+    } else if (has1) {
+      ox = nx[s1];
+      oz = nz[s1];
+    } else {
+      ox = nx[s0];
+      oz = nz[s0];
+    }
+    const p = path[i];
+    const l = put(p[0], p[1], ox, oz);
+    const r = put(p[0], p[1], -ox, -oz);
+    if (i === 0) {
+      firstL = l;
+      firstR = r;
+    } else {
+      b.triangle(prevL, prevR, l);
+      b.triangle(prevR, r, l);
+    }
+    prevL = l;
+    prevR = r;
+  }
+  if (closed) {
+    b.triangle(prevL, prevR, firstL);
+    b.triangle(prevR, firstR, firstL);
+  }
+}
+function wedge(b, c, half, css, a0, a1, error) {
+  const span = Math.abs(a1 - a0);
+  if (span < 1e-6) return;
+  const steps = arcSegments(half, span, css ? 0.5 : error);
+  const centre = css ? b.vertex(c[0], c[1], 1, 0, 0, half) : b.vertex(c[0], c[1], 1, 0, 0, 0);
+  let prev = -1;
+  for (let i = 0; i <= steps; i++) {
+    const a = a0 + (a1 - a0) * i / steps;
+    const ox = Math.cos(a);
+    const oz = Math.sin(a);
+    const v = css ? b.vertex(c[0], c[1], 1, ox, oz, half) : b.vertex(c[0] + ox * half, c[1] + oz * half, 1, 0, 0, 0);
+    if (prev >= 0) b.triangle(centre, prev, v);
+    prev = v;
+  }
+}
+function roundDot(b, c, half, css, error) {
+  wedge(b, c, half, css, 0, Math.PI * 2, error);
+}
+function tessellate(geometry, style, options = {}) {
+  const error = 0.5 / (options.pixelsPerUnit ?? 256);
+  const { rings, closed } = outline(geometry, error);
+  let estimate = 0;
+  for (const r of rings) estimate += r.length;
+  const b = new Builder(estimate * 6 + 16, estimate * 12 + 24);
+  if (style.fill && closed) fillRings(b, rings);
+  if (style.strokeWidth > 0) {
+    const css = style.strokeUnits === "css-px";
+    const half = style.strokeWidth / 2;
+    const round = geometry.kind === "pen";
+    for (const ring of rings) strokePath(b, ring, closed, half, css, round, error);
+  }
+  return b.finish();
+}
+function meshArea(mesh, u) {
+  let area = 0;
+  const p = mesh.positions;
+  for (let i = 0; i < mesh.indices.length; i += 3) {
+    const a = mesh.indices[i];
+    const b = mesh.indices[i + 1];
+    const c = mesh.indices[i + 2];
+    if (u !== void 0 && mesh.uvs[a * 2] !== u) continue;
+    area += Math.abs(
+      (p[b * 3] - p[a * 3]) * (p[c * 3 + 2] - p[a * 3 + 2]) - (p[c * 3] - p[a * 3]) * (p[b * 3 + 2] - p[a * 3 + 2])
+    ) / 2;
+  }
+  return area;
+}
+export {
+  meshArea,
+  parseGeometry,
+  tessellate
+};

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "@aethervtt/shard-vector",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./tessellate": {
+      "types": "./dist/tessellate.d.ts",
+      "default": "./dist/tessellate.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@aethervtt/shard-core": "0.1.0",
+    "@aethervtt/shard-mesh": "0.1.0",
+    "@aethervtt/shard-render": "0.1.0",
+    "@aethervtt/shard-runtime": "0.1.0",
+    "@aethervtt/shard-transform": "0.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aethervtt/shard.git",
+    "directory": "packages/vector"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "shard": {
+    "buildSha": "8e14c9896f82a3554b156f1ffdd68f2cc3e7d78a"
+  }
+}