kireji 0.12.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "kireji",
- "version": "0.12.0",
+ "version": "0.13.0",
  "description": "A web framework for stateful, entropy-perfect, multi-origin web applications. Currently in alpha. Expect breaking changes for version 0. Use with caution!",
  "files": [
   "src/",

package/src/app/kireji/issue-tracker/pathname-translate-canonical.js

@@ -1,7 +1,5 @@
 const { model } = _
 
-debug('yes, it is translating ...')
-
 if (!("app" in model))
  model.app = {}
 
@@ -20,14 +18,6 @@ if (PATHNAME === "/") {
 
  const parts = PATHNAME.split("/").slice(1)
 
- debug({
-  parts,
-  badSubpath: parts[0] !== "issues",
-  missingCode: !parts[1],
-  wrongLength: parts.length !== 2,
-  isNaN: isNaN(parts[1]),
-  notFound: !(parts[1] in kirejiIssueTracker.sections.issues)
- })
  if (parts[0] !== "issues" || !parts[1] || parts.length !== 2 || isNaN(parts[1]) || !(parts[1] in kirejiIssueTracker.sections.issues))
   throw "Unknown Canonical Path: " + PATHNAME
 

package/src/build.js

@@ -147,7 +147,16 @@ function ƒ(_, compressedSubjectOrigins) {
    return this.operate(value1, value2, (a, b) => a * b)
   }
   static dot(vector1, vector2) {
-   return vector1.x * vector2.x + vector1.y * vector2.y
+   let result = 0
+   const dimensions = Object.keys(vector1)
+
+   if (dimensions.some(key => !(key in vector2)) || Object.keys(vector2).some(key => !(key in vector1)))
+    throw new Error(`Vector Dot Product Error: the two vectors do not have the same keys.`)
+
+   for (const dimension of dimensions)
+    result += vector1[dimension] * vector2[dimension]
+
+   return result
   }
  }
  class FenwickTree {

package/src/parts/abstract/mesh/build.js

@@ -1,7 +1,7 @@
 mesh.define({
  triTable: { value: [] },
  triIndex: { value: -1, writable: true },
- position: { value: { x: null, y: null } },
+ position: { value: { x: null, y: null, z: null } },
  data: {
   resolve() {
    return mesh.getData()
@@ -23,21 +23,21 @@ mesh.define({
     // Recover the true points of the tri.
     const points = tri.map(pointID => pointList[pointID])
 
-    // Get just the y-coordinate of all the points.
-    const yPoints = points.map(point => point[1])
+    // Get just the z-coordinate of all the points.
+    const zPoints = points.map(point => point[2])
 
-    // Estimate the y-range of this tri.
-    const range = {
-     min: Math.min(...yPoints),
-     max: Math.max(...yPoints)
+    // Estimate the z-range of this tri.
+    const zRange = {
+     min: Math.min(...zPoints),
+     max: Math.max(...zPoints)
     }
 
     // Iterate over the range inclusively to populate each row subspace.
     const rows = []
-    for (let rowID = range.min; rowID <= range.max; rowID++) {
+    for (let z = zRange.min; z <= zRange.max; z++) {
 
      // This irrational offset ensures that all grid points lie vertically in at most one triangular region.
-     const offsetRowID = rowID + (Math.PI / 3.141 - 0.5)
+     const offsetRowID = z + (Math.PI / 3.141 - 0.5)
 
      // Iterate over the 3 lines in order to determine where the edges intersect the given row.
      const intersections = []
@@ -46,35 +46,45 @@ mesh.define({
       const pointA = points[edgeID]
       const pointB = points[(edgeID + 1) % 3]
 
-      if ((pointA[1] <= offsetRowID && pointB[1] > offsetRowID) || (pointB[1] <= offsetRowID && pointA[1] > offsetRowID))
-       intersections.push(pointA[0] + ((offsetRowID - pointA[1]) / (pointB[1] - pointA[1])) * (pointB[0] - pointA[0]))
+      if ((pointA[2] <= offsetRowID && pointB[2] > offsetRowID) || (pointB[2] <= offsetRowID && pointA[2] > offsetRowID)) {
+       const t = (offsetRowID - pointA[2]) / (pointB[2] - pointA[2])
+       intersections.push({
+        x: pointA[0] + t * (pointB[0] - pointA[0]),
+        y: pointA[1] + t * (pointB[1] - pointA[1])
+       })
+      }
      }
 
      if (intersections.length < 2) {
-      // This row doesn't have a full pixel. Adjust the range.
-      if (rowID <= range.min + 1) range.min = rowID + 1
-      else if (rowID >= range.max - 1) range.max = rowID - 1
+      // This row doesn't have a full pixel. Adjust the z-range.
+      if (z <= zRange.min + 1) zRange.min = z + 1
+      else if (z >= zRange.max - 1) zRange.max = z - 1
       else throw new Error("Unexpected tri geometry found in mesh.")
       continue
      }
 
+     const [min, max] = intersections[0].x <= intersections[1].x
+      ? [intersections[0], intersections[1]]
+      : [intersections[1], intersections[0]]
+
+     min.x = Math.ceil(min.x)
+     max.x = Math.ceil(max.x) - 1
+
      /** @type {IMeshTriDataRow} */
      const row = {
-      y: rowID,
-      range: {
-       min: Math.ceil(Math.min(...intersections)),
-       max: Math.ceil(Math.max(...intersections)) - 1,
-      },
-      offset: triCardinality
+      z,
+      xyRange: { min, max },
+      offset: triCardinality,
+      cardinality: BigInt(max.x - min.x + 1)
      }
      rows.push(row)
-     triCardinality += BigInt(row.range.max - row.range.min + 1)
+     triCardinality += row.cardinality
     }
 
     // Store the tri.
     mesh.triTable.push({
      points,
-     range,
+     zRange,
      rows,
      offset: meshCardinality,
      cardinality: triCardinality

package/src/parts/abstract/mesh/data-get.js

@@ -2,9 +2,8 @@ const { points, tris } = mesh.manifest
 
 const data = { collision: [[], []] }
 
-// TODO: add a y coordinate use a default 0 for 2D meshes.
 for (let index = 0; index < points.length; index += 2)
- data.collision[0].push([Math.round(points[index]), Math.round(points[index + 1])])
+ data.collision[0].push([Math.round(points[index]), 0, Math.round(points[index + 1])])
 
 for (let index = 0; index < tris.length; index += 3)
  data.collision[1].push([tris[index], tris[index + 1], tris[index + 2]])

package/src/parts/abstract/mesh/point-tri-contains.js

@@ -1,14 +1,14 @@
-const roundedY = Math.floor(POINT.y)
+const flooredZ = Math.floor(POINT.z)
 const triData = mesh.triTable[TRI_INDEX]
 
-if (roundedY < triData.range.min || roundedY > triData.range.max)
+if (flooredZ < triData.zRange.min || flooredZ > triData.zRange.max)
  return false
 
-const row = triData.rows[roundedY - triData.range.min]
+const row = triData.rows[flooredZ - triData.zRange.min]
 
 if (!row)
  return false
 
 const roundedX = Math.floor(POINT.x)
 
-return roundedX >= row.range.min && roundedX <= row.range.max
+return roundedX >= row.xyRange.min.x && roundedX <= row.xyRange.max.x

package/src/parts/abstract/mesh/ray-cast.js

@@ -1,259 +1,282 @@
 // Define a safe result: the current position before casting.
+/** @type {IMeshRayCastResult} */
 const safeIterationResult = {
  hit: false,
  triIndex: mesh.triIndex,
- point: { ...mesh.position },
+ point: {
+  x: mesh.position.x,
+  y: 0, // Exclude y from ray cast calculations for now.
+  z: mesh.position.z
+ },
  forceVector: FORCE_VECTOR
 }
 
 // Obtain the speed of the force vector, which will be used later if we need to slide along the boundary.
 const speed = Vector.magnitude(FORCE_VECTOR)
 
-// If there's no motion, nothing will happen. Return the safe result.
-if (speed === 0)
- return safeIterationResult
+// Only cast a ray if there's movement happening.
+if (speed !== 0) {
 
-// Otherwise, initialize timing data as though the vector doesn't intersect any grid lines.
-const timeOfNextIntersection = { x: Infinity, y: Infinity }
-const timeBetweenIntersections = { ...timeOfNextIntersection }
+ // Initialize timing data as though the vector doesn't intersect any grid lines.
+ const timeOfNextIntersection = { x: Infinity, z: Infinity }
+ const timeBetweenIntersections = { ...timeOfNextIntersection }
 
-// Set the clock to zero.
-let time = 0
+ // Set the clock to zero.
+ let time = 0
 
-function initializeRayIntersectionSchedule(alsoComputeIntersectionInterval) {
+ function initializeRayIntersectionSchedule(alsoComputeIntersectionInterval) {
 
- // If the force vector isn't parallel to the x axis...
- if (FORCE_VECTOR.x !== 0) {
+  // If the force vector isn't parallel to the x axis...
+  if (FORCE_VECTOR.x !== 0) {
 
-  // Determine the x coordinate of the first grid line the ray may intersect.
-  const nextGridX = Math.floor(safeIterationResult.point.x) + (FORCE_VECTOR.x > 0)
+   // Determine the x coordinate of the first grid line the ray may intersect.
+   const nextGridX = Math.floor(safeIterationResult.point.x) + (FORCE_VECTOR.x > 0)
 
-  // Compute the exact moment that intersection will happen.
-  timeOfNextIntersection.x = time + (nextGridX - safeIterationResult.point.x) / FORCE_VECTOR.x
+   // Compute the exact moment that intersection will happen.
+   timeOfNextIntersection.x = time + (nextGridX - safeIterationResult.point.x) / FORCE_VECTOR.x
 
-  // Compute the constant time between each grid line intersection.
-  if (alsoComputeIntersectionInterval)
-   timeBetweenIntersections.x = 1 / Math.abs(FORCE_VECTOR.x)
- }
+   // Compute the constant time between each grid line intersection.
+   if (alsoComputeIntersectionInterval)
+    timeBetweenIntersections.x = 1 / Math.abs(FORCE_VECTOR.x)
+  }
 
- // Perform the same steps for the y-axis.
- if (FORCE_VECTOR.y !== 0) {
-  const nextGridY = Math.floor(safeIterationResult.point.y) + (FORCE_VECTOR.y > 0)
-  timeOfNextIntersection.y = time + (nextGridY - safeIterationResult.point.y) / FORCE_VECTOR.y
-  if (alsoComputeIntersectionInterval)
-   timeBetweenIntersections.y = 1 / Math.abs(FORCE_VECTOR.y)
+  // Perform the same steps for the z-axis.
+  if (FORCE_VECTOR.z !== 0) {
+   const nextGridZ = Math.floor(safeIterationResult.point.z) + (FORCE_VECTOR.z > 0)
+   timeOfNextIntersection.z = time + (nextGridZ - safeIterationResult.point.z) / FORCE_VECTOR.z
+   if (alsoComputeIntersectionInterval)
+    timeBetweenIntersections.z = 1 / Math.abs(FORCE_VECTOR.z)
+  }
  }
-}
 
-initializeRayIntersectionSchedule(true)
+ initializeRayIntersectionSchedule(true)
 
-const start = _.now
+ const start = _.now
 
-let iteration = 0
+ let iteration = 0
 
-// Start iterating on the ray cast.
-while (true) {
+ // Start iterating on the ray cast.
+ castRay: while (true) {
 
- iteration++
+  iteration++
 
- // Emergency exit the loop.
- if (_.now - start >= (DELTA_TIME * 1000))
-  throw { error: "LOCKED WHILE LOOP", processingTime: _.now - start, iteration, DELTA_TIME, FORCE_VECTOR, speed, safeIterationResult, timeOfNextIntersection, timeBetweenIntersections }
+  // Emergency exit the loop.
+  if (_.now - start >= 2000) {
+   warn("Mesh ray cast calculation exceeded the maximum allowable processing time of 2 seconds.", { processingTime: _.now - start, iteration, DELTA_TIME, FORCE_VECTOR, speed, safeIterationResult, timeOfNextIntersection, timeBetweenIntersections })
+   break castRay
+  }
 
- // Pick the dimension whose grid intersection will happen next.
- const dimension = timeOfNextIntersection.x < timeOfNextIntersection.y ? "x" : "y"
+  // Pick the dimension whose grid intersection will happen next.
+  const dimension = timeOfNextIntersection.x < timeOfNextIntersection.z ? "x" : "z"
 
- // Note how much time must elapse to reach that intersection.
- let timeElapsedDuringThisIteration = timeOfNextIntersection[dimension] - time
+  // Note how much time must elapse to reach that intersection.
+  let timeElapsedDuringThisIteration = timeOfNextIntersection[dimension] - time
 
- // Set the clock to the moment of that intersection.
- time += timeElapsedDuringThisIteration
+  // Set the clock to the moment of that intersection.
+  time += timeElapsedDuringThisIteration
 
- // Note if this is a case where the grid intersection is reached after the time limit.
- let ranOutOfTime = time >= DELTA_TIME
+  // Note if this is a case where the grid intersection is reached after the time limit.
+  let ranOutOfTime = time >= DELTA_TIME
 
- // In that case...
- if (ranOutOfTime) {
+  // In that case...
+  if (ranOutOfTime) {
 
-  // Measure how far we are past the time limit.
-  const overshootTime = time - DELTA_TIME
+   // Measure how far we are past the time limit.
+   const overshootTime = time - DELTA_TIME
 
-  // Adjust how much time we say elapsed.
-  timeElapsedDuringThisIteration -= overshootTime
+   // Adjust how much time we say elapsed.
+   timeElapsedDuringThisIteration -= overshootTime
 
-  // Set the block back to the last possible moment.
-  time = DELTA_TIME
- }
+   // Set the block back to the last possible moment.
+   time = DELTA_TIME
+  }
 
- // Construct the next point along the ray, given the elapsed time.
- const point = Vector.add(safeIterationResult.point, Vector.multiply(FORCE_VECTOR, timeElapsedDuringThisIteration))
+  // Construct the next point along the ray, given the elapsed time.
+  const point = Vector.add(safeIterationResult.point, Vector.multiply(FORCE_VECTOR, timeElapsedDuringThisIteration))
 
- // Check if the point is outside the mesh boundary.
- const triIndex = mesh.triThatContainsPoint(point)
+  // Check if the point is outside the mesh boundary.
+  const triIndex = mesh.triThatContainsPoint(point)
 
- // If it is...
- if (triIndex === -1) {
+  // If it is...
+  if (triIndex === -1) {
 
-  // We are at a boundary pixel. Let's move our position to exactly the center of our current point.
-  // safeIterationResult.point = Vector.add(Vector.floor(safeIterationResult.point), 0.5)
+   // We are at a boundary pixel. Let's move our position to exactly the center of our current point.
+   // safeIterationResult.point = Vector.add(Vector.floor(safeIterationResult.point), 0.5)
 
-  // If we have permission to simulate sliding...
-  if (ENABLE_SLIDING) {
+   // If we have permission to simulate sliding...
+   if (ENABLE_SLIDING) {
 
-   // Walk back the clock to before the ray hit.
-   time -= timeElapsedDuringThisIteration
+    // Walk back the clock to before the ray hit.
+    time -= timeElapsedDuringThisIteration
 
-   const neighbor = {
-    dot: -Infinity,
-    point: null,
-    triIndex: null,
-    direction: {
-     x: null,
-     y: null
+    const neighbor = {
+     dot: -Infinity,
+     point: null,
+     triIndex: null,
+     direction: {
+      x: null,
+      z: null
+     }
     }
-   }
 
-   let boundaryAppearsFlat = false
-
-   // Search the local neighborhood of points for one that we can safely move to.
-   for (let x = -1; x <= 1; x++) for (let y = -1; y <= 1; y++) {
-
-    // Exclude the point itself
-    if (!x && !y)
-     continue
-
-    const direction = { x, y }
-
-    // Find out how much of the force vector is cancelled out by going to this neighbor.
-    const dot = Vector.dot(Vector.normalize(direction), Vector.normalize(FORCE_VECTOR))
-
-    // If it would require traveling "against" or perpendicular to the force vector, exclude it from consideration.
-    if (dot < 0)
-     continue
+    let boundaryAppearsFlat = false
+
+    // Search the local neighborhood of points for one that we can safely move to.
+    for (let x = -1; x <= 1; x++) for (let z = -1; z <= 1; z++) {
+
+     // Exclude the point itself
+     if (!x && !z)
+      continue
+
+     const direction = { x, y: 0, z }
+
+     // Find out how much of the force vector is cancelled out by going to this neighbor.
+     const dot = Vector.dot(Vector.normalize(direction), Vector.normalize(FORCE_VECTOR))
+
+     // If it would require traveling "against" or perpendicular to the force vector, exclude it from consideration.
+     if (dot < 0)
+      continue
+
+     // Get the position of the center of the neighbor.
+     const point = Vector.add(Vector.floor(Vector.add(safeIterationResult.point, direction)), 0.5)
+     const triIndex = mesh.triThatContainsPoint(point)
+
+     // If it isn't part of the mesh, exclude it from consideration.
+     if (triIndex === -1)
+      continue
+
+     // Store the neighbor which most agrees with the force vector.
+     if (dot >= neighbor.dot) {
+      if (dot < 0.05 && neighbor.dot !== -Infinity && neighbor.dot < 0.05) {
+       boundaryAppearsFlat = true
+       // Boundary is "flat". Don't allow perpendicular motion.
+       neighbor.dot = -Infinity
+       neighbor.point = null
+       neighbor.triIndex = null
+       neighbor.direction.x = null
+       neighbor.direction.z = null
+      } else {
+       boundaryAppearsFlat = false
+       neighbor.dot = dot
+       neighbor.point = point
+       neighbor.triIndex = triIndex
+       neighbor.direction = direction
+      }
+     }
+    }
 
-    // Get the position of the center of the neighbor.
-    const point = Vector.add(Vector.floor(Vector.add(safeIterationResult.point, direction)), 0.5)
-    const triIndex = mesh.triThatContainsPoint(point)
+    if (boundaryAppearsFlat) {
+     // Do nothing for now...
+    }
 
-    // If it isn't part of the mesh, exclude it from consideration.
-    if (triIndex === -1)
-     continue
+    // If there is no neighboring point, we are "stuck". The ray cast ends here.
+    if (!neighbor.point) {
 
-    // Store the neighbor which most agrees with the force vector.
-    if (dot >= neighbor.dot) {
-     if (dot < 0.05 && neighbor.dot !== -Infinity && neighbor.dot < 0.05) {
-      boundaryAppearsFlat = true
-      // Boundary is "flat". Don't allow perpendicular motion.
-      neighbor.dot = -Infinity
-      neighbor.point = null
-      neighbor.triIndex = null
-      neighbor.direction.x = null
-      neighbor.direction.y = null
-     } else {
-      boundaryAppearsFlat = false
-      neighbor.dot = dot
-      neighbor.point = point
-      neighbor.triIndex = triIndex
-      neighbor.direction = direction
-     }
+     // Return the safe result data.
+     safeIterationResult.hit = true
+     break castRay
     }
-   }
 
-   if (boundaryAppearsFlat) {
-    // Do nothing for now...
-   }
+    // Compute travel distance to the center of the neighbor.
+    const vectorToNeighbor = Vector.subtract(neighbor.point, safeIterationResult.point)
+    const distance = Vector.magnitude(vectorToNeighbor)
 
-   // If there is no neighboring point, we are "stuck". The ray cast ends here.
-   if (!neighbor.point) {
+    // Construct a force vector pointing to the chosen neighbor.
+    const forceVectorToNeighbor = Vector.multiply(Vector.normalize(vectorToNeighbor), speed)
 
-    // Return the safe result data.
-    safeIterationResult.hit = true
-    return safeIterationResult
-   }
+    // Compute travel time to reach the neighbor.
+    timeElapsedDuringThisIteration = distance / speed
 
-   // Compute travel distance to the center of the neighbor.
-   const vectorToNeighbor = Vector.subtract(neighbor.point, safeIterationResult.point)
-   const distance = Vector.magnitude(vectorToNeighbor)
+    // Move the clock ahead to our arrival at the neighbor.
+    time += timeElapsedDuringThisIteration
 
-   // Construct a force vector pointing to the chosen neighbor.
-   const forceVectorToNeighbor = Vector.multiply(Vector.normalize(vectorToNeighbor), speed)
+    // Check again if we ran out of time.
+    ranOutOfTime = time >= DELTA_TIME
+    if (ranOutOfTime) {
+     const overshootTime = time - DELTA_TIME
+     timeElapsedDuringThisIteration -= overshootTime
+     time = DELTA_TIME
 
-   // Compute travel time to reach the neighbor.
-   timeElapsedDuringThisIteration = distance / speed
+     // Construct the point along the way to the neighbor.
+     const point = Vector.add(safeIterationResult.point, Vector.multiply(forceVectorToNeighbor, timeElapsedDuringThisIteration))
+     const triIndex = mesh.triThatContainsPoint(point)
+     safeIterationResult.forceVector = forceVectorToNeighbor
 
-   // Move the clock ahead to our arrival at the neighbor.
-   time += timeElapsedDuringThisIteration
+     if (triIndex === -1) {
+      // We didn't have enough time to overcome the diagonal boundary.
 
-   // Check again if we ran out of time.
-   ranOutOfTime = time >= DELTA_TIME
-   if (ranOutOfTime) {
-    const overshootTime = time - DELTA_TIME
-    timeElapsedDuringThisIteration -= overshootTime
-    time = DELTA_TIME
+      if (speed * DELTA_TIME > Math.SQRT2) {
+       // The current speed is enough to overcome diagonal corners.
 
-    // Construct the point along the way to the neighbor.
-    const point = Vector.add(safeIterationResult.point, Vector.multiply(forceVectorToNeighbor, timeElapsedDuringThisIteration))
-    const triIndex = mesh.triThatContainsPoint(point)
-    safeIterationResult.forceVector = forceVectorToNeighbor
+       // Return the previous safe point, chalking the lost time up to friction.
+       break castRay
+      }
 
-    if (triIndex === -1) {
-     // We didn't have enough time to overcome the diagonal boundary.
+      // There is not enough velocity to overcome the diagonal. Use random chance.
+      if (Math.random() < Math.SQRT1_2) {
+       safeIterationResult.point = neighbor.point
+       safeIterationResult.triIndex = neighbor.triIndex
+      }
 
-     if (speed * DELTA_TIME > Math.SQRT2) {
-      // The current speed is enough to overcome diagonal corners.
-
-      // Return the previous safe point, chalking the lost time up to friction.
-      return safeIterationResult
-     }
+      break castRay
+     } else {
 
-     // There is not enough velocity to overcome the diagonal. Use random chance.
-     if (Math.random() < Math.SQRT1_2) {
-      safeIterationResult.point = neighbor.point
-      safeIterationResult.triIndex = neighbor.triIndex
+      // Go to the partial point.
+      safeIterationResult.point = point
+      safeIterationResult.triIndex = triIndex
      }
 
-     return safeIterationResult
-    } else {
-
-     // Go to the partial point.
-     safeIterationResult.point = point
-     safeIterationResult.triIndex = triIndex
+     break castRay
     }
 
-    return safeIterationResult
-   }
-
-   // Set the neighbor as the new safe point.
-   safeIterationResult.point = neighbor.point
-   safeIterationResult.triIndex = neighbor.triIndex
-   safeIterationResult.forceVector = FORCE_VECTOR
+    // Set the neighbor as the new safe point.
+    safeIterationResult.point = neighbor.point
+    safeIterationResult.triIndex = neighbor.triIndex
+    safeIterationResult.forceVector = FORCE_VECTOR
 
-   // The normal ray intersection schedule has changed.
-   initializeRayIntersectionSchedule()
+    // The normal ray intersection schedule has changed.
+    initializeRayIntersectionSchedule()
 
-   // Proceed with normal ray casting behavior from this point.
-   continue
+    // Proceed with normal ray casting behavior from this point.
+    continue
 
-  } else {
+   } else {
 
-   // Discard the unsafe point. Return the safe result data.
-   safeIterationResult.hit = true
-   return safeIterationResult
+    // Discard the unsafe point. Return the safe result data.
+    safeIterationResult.hit = true
+    break castRay
+   }
   }
- }
 
 
- // Otherwise, update the safe result.
- safeIterationResult.point = point
- safeIterationResult.triIndex = triIndex
+  // Otherwise, update the safe result.
+  safeIterationResult.point = point
+  safeIterationResult.triIndex = triIndex
 
- // If we ran out of time...
- if (ranOutOfTime) {
+  // If we ran out of time...
+  if (ranOutOfTime) {
 
-  // We're done. Return the safe point.
-  return safeIterationResult
+   // We're done. Return the safe point.
+   break castRay
+  }
+
+  // Otherwise, Prepare for the next grid line time of this dimension.
+  timeOfNextIntersection[dimension] += timeBetweenIntersections[dimension]
  }
+}
 
- // Otherwise, Prepare for the next grid line time of this dimension.
- timeOfNextIntersection[dimension] += timeBetweenIntersections[dimension]
-}
+// Interpolate the y position of the collision mesh at the given { x, y } coordinates.
+const triData = mesh.triTable[safeIterationResult.triIndex]
+const flooredZ = Math.floor(safeIterationResult.point.z)
+const row = triData.rows[flooredZ - triData.zRange.min]
+const t = (safeIterationResult.point.x - row.xyRange.min.x) / Number(row.cardinality)
+safeIterationResult.point.y = row.xyRange.min.y + t * (row.xyRange.max.y - row.xyRange.min.y)
+
+if (isNaN(safeIterationResult.point.y))
+ throw {
+  triData,
+  flooredZ,
+  row,
+  t
+ }
+return safeIterationResult

package/src/parts/abstract/mesh/routeID-distribute.js

@@ -35,11 +35,11 @@ for (const row of mesh.triTable[mesh.triIndex].rows) {
  if (!row)
   continue
 
- const rowWidth = BigInt(row.range.max - row.range.min + 1)
+ const rowWidth = BigInt(row.xyRange.max.x - row.xyRange.min.x + 1)
 
  if (ROUTE_ID < row.offset + rowWidth) {
-  mesh.position.y = row.y
-  mesh.position.x = row.range.min + Number(ROUTE_ID - row.offset)
+  mesh.position.x = row.xyRange.min.x + Number(ROUTE_ID - row.offset)
+  mesh.position.z = row.z
   break
  }
 }

package/src/parts/abstract/mesh/routeID-model-to.js

@@ -1,4 +1,4 @@
 const triIndex = mesh.triThatContainsPoint(MODEL)
 const triData = mesh.triTable[triIndex]
-const row = triData.rows[Math.floor(MODEL.y) - triData.range.min]
-return triData.offset + row.offset + BigInt(Math.floor(MODEL.x) - row.range.min)
+const row = triData.rows[Math.floor(MODEL.z) - triData.zRange.min]
+return triData.offset + row.offset + BigInt(Math.floor(MODEL.x) - row.xyRange.min.x)

package/src/parts/abstract/mesh/type.d.ts

@@ -4,20 +4,11 @@ declare interface IMesh<TOwner>
  // Serialized Properties.
  readonly getData(): IMeshData
  /** Casts a ray from the current mesh position along the force vector direction for the given delta time and returns a summary of the results. @param FORCE_VECTOR the force vector represent the position the uninterrupted ray will arrive at in one second. @param DELTA_TIME the duration of the time cast in seconds. @param ENABLE_SLIDING whether or not to enable the ray to "wrap" along the mesh boundary instead of stopping cold. */
- readonly castRay(FORCE_VECTOR: IVector2, DELTA_TIME: number, ENABLE_SLIDING: boolean): {
-  /** Whether or not the ray hit the mesh boundary. */
-  readonly hit: boolean
-  /** The tri the ray most recently occupied when it hit the boundary or the index of the boundary where the ray stopped if there is no hit. */
-  readonly triIndex: IMeshTriIndex
-  /** The rounded cell position where the cast ray landed. */
-  readonly position: IVector2
-  /** The force vector used to cast the ray, which might be different from the input if sliding is enabled as it may point along the direction of the most recent sliding iteration. */
-  readonly forceVector: IVector2
- }
- /** Checks if a point (x, y) rounds to a valid pixel within the specified tri's memoized row data. */
- readonly triContainsPoint(TRI_INDEX: IMeshTriIndex, POINT: IVector2): boolean
+ readonly castRay(FORCE_VECTOR: IVector3, DELTA_TIME: number, ENABLE_SLIDING: boolean): IMeshRayCastResult
+ /** Checks if a point (x, y, z) rounds to a valid pixel within the specified tri's memoized row data. */
+ readonly triContainsPoint(TRI_INDEX: IMeshTriIndex, POINT: IVector3): boolean
  /** Returns whether or not the given point is in a tri. @returns the index of the tri that contains the point. -1 otherwise. */
- readonly triThatContainsPoint(POINT: IVector2): IMeshTriIndex
+ readonly triThatContainsPoint(POINT: IVector3): IMeshTriIndex
 
  // Runtime Properties.
  /** The memoization data of every tri in the mesh, stored by tri index at build-time. */
@@ -25,20 +16,31 @@ declare interface IMesh<TOwner>
  /** The index of the current tri in the mesh. */
  readonly triIndex?: IMeshTriIndex
  /** The current position of the state in the mesh. */
- readonly position: IVector2
+ readonly position: IVector3
  readonly manifest: IMeshManifest
  /** A cache of the pre-processed geometry data obtained by running the getData method. */
  readonly data: IMeshData
 }
 
+declare interface IMeshRayCastResult {
+ /** Whether or not the ray hit the mesh boundary. */
+ readonly hit: boolean
+ /** The tri the ray most recently occupied when it hit the boundary or the index of the boundary where the ray stopped if there is no hit. */
+ readonly triIndex: IMeshTriIndex
+ /** The rounded cell position where the cast ray landed. */
+ readonly point: IVector3
+ /** The force vector used to cast the ray, which might be different from the input if sliding is enabled as it may point along the direction of the most recent sliding iteration. */
+ readonly forceVector: IVector3
+}
+
 declare interface IMeshTriData {
  /** The original point array of the tri as taken from `mesh.getData()`. */
  readonly points: IMeshTriPoints
- /** The y-axis range of the tri. */
- readonly range: {
-  /** The y position of the top-most row of the tri. */
+ /** The z-axis range of the tri. */
+ readonly zRange: {
+  /** The z position of the top-most row of the tri. */
   readonly min: number
-  /** The y position of the bottom-most row of the tri. */
+  /** The z position of the bottom-most row of the tri. */
   readonly max: number
  }
  /** The rows of pixels in the tri. */
@@ -50,17 +52,25 @@ declare interface IMeshTriData {
 }
 
 declare interface IMeshTriDataRow {
- /** The y position of this row of the tri's space. */
- readonly y: number
- /** The x-axis range of the row. */
- readonly range: {
+ /** The z position of this row of the tri's space. */
+ readonly z: number
+ /** The x-axis range of the row stored with the corresponding y-axis coordinate at those two points. */
+ readonly xyRange: {
   /** The smallest x position that is within the tri row. */
-  readonly min: number
+  readonly min: {
+   readonly x: number,
+   readonly y: number
+  }
   /** The largest x position that is within the tri row. */
-  readonly max: number
+  readonly max: {
+   readonly x: number,
+   readonly y: number
+  }
  }
  /** The bigint offset of this row in the overall tri. */
  readonly offset: bigint
+ /** The number of points in the given row. */
+ readonly cardinality: bigint
 }
 
 
@@ -86,7 +96,7 @@ declare type IMeshTriPoints =
  [IMeshPoint, IMeshPoint, IMeshPoint]
 
 declare type IMeshPoint =
- [x: number, y: number]
+ [x: number, y: number, z: number]
 
 declare type IMeshTriIndex =
  number

package/src/parts/abstract/part/mathML.js

@@ -9,8 +9,6 @@ const expression = (() => {
 
  const needsParentheses = PARENTHESIZE && terms.length > 1
 
- debug(terms)
-
  // Allow "<mrow>" tag nesting for parentheses.
  return (LABELS ? "<munder>" + (needsParentheses ? "" : "<mrow>") : "") + (needsParentheses ? "<mrow class=parenthetic><mo>(</mo>" : "") + terms.join("") + (needsParentheses ? `<mo>)</mo></mrow>` : "") + (LABELS ? (needsParentheses ? "" : "</mrow>") + `<munder><mo stretchy="true">&#x23df;</mo>${recurse(0, "none", false, false)}</munder></munder>` : "")
 })()

package/src/parts/abstract/scroller/onscroll.js

@@ -1,6 +1,4 @@
 if (scroller.skipRouteIDUpdate || !client.hydrated) {
- if (!client.hydrated)
-  debug('onscroll from within the hydration phase')
  scroller.skipRouteIDUpdate = false
 } else {
  const maxY = scroller.container.scrollHeight

package/src/parts/core/agent/fullscreen-toggle.js

@@ -0,0 +1,28 @@
+if (!document.fullscreenElement) {
+
+ if (FORCE_STATE === false)
+  return FORCE_STATE
+
+ if (document.documentElement.requestFullscreen) {
+  document.documentElement.requestFullscreen()
+ } else if (document.documentElement.webkitRequestFullscreen) {
+  document.documentElement.webkitRequestFullscreen()
+ } else if (document.documentElement.msRequestFullscreen) {
+  document.documentElement.msRequestFullscreen()
+ }
+ return true
+} else {
+
+ if (FORCE_STATE === true)
+  return FORCE_STATE
+
+ if (document.exitFullscreen) {
+  document.exitFullscreen()
+ } else if (document.webkitExitFullscreen) {
+  document.webkitExitFullscreen()
+ } else if (document.msExitFullscreen) {
+  document.msExitFullscreen()
+ }
+}
+
+return false

package/src/parts/core/agent/part.json

@@ -1,3 +1,8 @@
 {
- "extends": "facet"
+ "extends": "facet",
+ "methods": {
+  "fullscreen-toggle": [
+   "FORCE_STATE"
+  ]
+ }
 }

package/src/parts/core/agent/type.d.ts

@@ -4,6 +4,10 @@ interface IAgent
  // Runtime Properties.
  readonly isMac: boolean
  readonly isSafari: boolean
+
+ // Serialized Properties.
+ /** Toggles the native fullscreen feature (if available) and returns the resulting state. If FORCE_STATE is provided, sets the fullscreen mode to the given state, instead of simply toggling it. */
+ readonly toggleFullscreen(FORCE_STATE?: boolean = undefined)
 }
 
 declare const agent: IAgent

package/src/parts/desktop/about/constants.js

@@ -0,0 +1 @@
+const aboutEcosystem = this

package/src/parts/desktop/about/menu-item.html_.js

@@ -0,0 +1 @@
+return `<a ${_.application === aboutEcosystem ? "disabled" : _.pointAttr()} href=https://${aboutEcosystem.host}>About</a>`

package/src/parts/desktop/about/part.css

@@ -0,0 +1,3 @@
+#about_desktop_parts {
+ text-align: center;
+}

package/src/parts/desktop/about/part.html_.js

@@ -7,15 +7,14 @@ const longestHost = appNames.reduce((a, b) => (a.length >= b.length ? a : b))
 const worstCaseURL = `https://${longestHost}/${_.version}/${encodeSegment(_.cardinality - 1n)}/`
 const maxURLLength = 2000
 const stateSizeInBits = toBits(_.cardinality - 1n, false)
+const stateSizeInCharms = toCharms(_.cardinality - 1n, false)
 
 return /* html */`
 <h1>Demo Ecosystem</h1>
 ${_.parts.core.update["part.html"]}
-<ul>
- <li>Apps: ${appNames.length}</li>
- <li>JS Size: ${sizeInMB} MB (${sizeInKB} KB)</li>
- <li>JS Usage: ${sizeInMB / maxSizeInMB * 100}%</li>
- <li>State Size: ${stateSizeInBits} bits (${stateSizeInBits / 8000} KB)</li>
- <li>Worst URL: ${worstCaseURL.length} characters</li>
- <li>URL Usage: ${worstCaseURL.length / maxURLLength * 100}%</li>
-</ul>`
+<hr>
+<span>Installed Apps: ${appNames.length}</span>
+<br>
+<span>JS Usage: ${Math.round(sizeInMB / maxSizeInMB * 100)}% (${Math.round(sizeInMB * 100) / 100} MB / ${maxSizeInMB} MB)</span>
+<br>
+<span>URL Usage: ${Math.round(worstCaseURL.length / maxURLLength * 100)}%  (${worstCaseURL.length} ch / ${maxURLLength} ch)</span>`

package/src/parts/desktop/about/type.d.ts

@@ -0,0 +1,6 @@
+declare interface IAboutApplication
+ extends IApplication<IDesktop> {
+
+}
+
+declare const aboutEcosystem: IAboutApplication

package/src/parts/desktop/era/modern/part.css

@@ -33,6 +33,10 @@ title-bar>.part-icon {
  position: relative;
 }
 
+.toggle-control:hover {
+ color: var(--accent);
+}
+
 .toggle-control .base {
  width: 100%;
  border-radius: var(--spacing);
@@ -115,10 +119,6 @@ task-menu {
  width: auto;
 }
 
-task-menu [disabled] {
- display: none !important;
-}
-
 task-menu hr {
  display: none;
 }
@@ -148,6 +148,7 @@ task-menu>* {
 }
 
 #settings>span,
+#settings>a,
 .toggle-control {
  gap: 1ch;
  height: var(--spacing);
@@ -172,7 +173,6 @@ task-menu>* {
  top: 2px;
 }
 
-
 .toggle-control[data-state="enabled"] .handle {
  left: calc(var(--spacing) + 2px);
 }
@@ -199,8 +199,13 @@ task-menu>* {
  color: var(--accent);
 }
 
+#settings>a[disabled] {
+ color: var(--fg-mode-er);
+ cursor: default;
+}
+
 .task-link:not([data-here]):hover,
-#update-control:hover {
+#settings>a:not([disabled]):hover {
  color: var(--accent);
  cursor: pointer;
 }

package/src/parts/desktop/era/vintage/part.css_.js

@@ -1,6 +1,6 @@
 const menuApplicationsCount = Object.keys(_.menuApplications).length
-const controlLinesCount = 2
-const separatorCount = 2
+const controlLinesCount = 3
+const separatorCount = 1
 return part["static.css"] + `
 task-menu::after {
  content: "${_.application.fancyTitle}";

package/src/parts/desktop/era/vintage/static.css

@@ -112,7 +112,7 @@ scroll-bar>thumb- {
 }
 
 .task-link>a:hover,
-#update-control:hover {
+#settings>a:not([disabled]):hover {
  background: var(--accent);
  color: var(--bg-mode-est);
 }
@@ -255,13 +255,14 @@ hr {
 }
 
 [disabled],
-[disabled] * {
+[disabled] *,
+a[disabled] {
  pointer-events: none;
  color: var(--bg-dark-er);
  text-shadow: 1px 1px var(--bg-light-est);
 }
 
-body.dark :is([disabled], [disabled] *) {
+body.dark :is([disabled], [disabled] *, a[disabled]) {
  color: var(--bg-dark-est);
  text-shadow: 1px 1px var(--bg-light-er);
 }

package/src/parts/desktop/task-bar/menu/constants.js

@@ -1,4 +1,5 @@
 const menu = this
 const update = _.parts.core.update
 const color = _.parts.desktop.color
-const era = _.parts.desktop.era
+const era = _.parts.desktop.era
+const aboutEcosystem = _.parts.desktop.about

package/src/parts/desktop/task-bar/menu/menu.html_.js

@@ -3,7 +3,7 @@ const
  sections = []
 
 // if (_.includeUpdates === "full" || (!production && _.includeUpdates === "local-only"))
-// controls.push(update["part.html"])
+controls.push(aboutEcosystem["menu-item.html"])
 
 if (_.includeColor === "full" || (!production && _.includeColor.startsWith("debug-")))
  controls.push(color["part.html"])

package/src/parts/desktop/task-bar/tray/fullscreen/point.js

@@ -1,22 +1,6 @@
 pointer.handle({
  click() {
-  if (!document.fullscreenElement) {
-   if (document.documentElement.requestFullscreen) {
-    document.documentElement.requestFullscreen()
-   } else if (document.documentElement.webkitRequestFullscreen) {
-    document.documentElement.webkitRequestFullscreen()
-   } else if (document.documentElement.msRequestFullscreen) {
-    document.documentElement.msRequestFullscreen()
-   }
-  } else {
-   if (document.exitFullscreen) {
-    document.exitFullscreen()
-   } else if (document.webkitExitFullscreen) {
-    document.webkitExitFullscreen()
-   } else if (document.msExitFullscreen) {
-    document.msExitFullscreen()
-   }
-  }
+  _.parts.core.agent.toggleFullScreen()
  },
  POINTER_EVENT,
  TARGET_ELEMENT,

package/src/static.css

@@ -191,6 +191,7 @@ task-menu {
 }
 
 #settings>span,
+#settings>a,
 .toggle-control {
  display: flex;
  justify-content: space-between;
@@ -198,6 +199,14 @@ task-menu {
  gap: 5px;
 }
 
+#settings>a:not([disabled]) {
+ color: inherit;
+}
+
+#settings>a {
+ text-decoration: none;
+}
+
 .task-link {
  display: contents;
 }

package/src/type.d.ts

@@ -415,6 +415,7 @@ declare class Vector {
 
 declare type IVector = Record<string, number>
 declare type IVector2 = { x: number, y: number }
+declare type IVector3 = { x: number, y: number, z: number }
 
 declare type KirejiConfigColor =
  /** The color component will never be included. */