kireji 0.6.8 → 0.8.0

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

@@ -0,0 +1,262 @@
+// Define a safe result: the current position before casting.
+const safeIterationResult = {
+ hit: false,
+ triIndex: mesh.triIndex,
+ point: { ...mesh.position },
+ 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
+
+// Otherwise, initialize timing data as though the vector doesn't intersect any grid lines.
+const timeOfNextIntersection = { x: Infinity, y: Infinity }
+const timeBetweenIntersections = { ...timeOfNextIntersection }
+
+// Set the clock to zero.
+let time = 0
+
+function initializeRayIntersectionSchedule(alsoComputeIntersectionInterval) {
+
+ // 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)
+
+  // 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)
+ }
+
+ // 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)
+ }
+}
+
+initializeRayIntersectionSchedule(true)
+
+const start = _.now
+
+let iteration = 0
+
+// Start iterating on the ray cast.
+while (true) {
+
+ 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 }
+
+ // Pick the dimension whose grid intersection will happen next.
+ const dimension = timeOfNextIntersection.x < timeOfNextIntersection.y ? "x" : "y"
+
+ // 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
+
+ // 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) {
+
+  // Measure how far we are past the time limit.
+  const overshootTime = time - DELTA_TIME
+
+  // Adjust how much time we say elapsed.
+  timeElapsedDuringThisIteration -= overshootTime
+
+  // 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))
+
+ // Check if the point is outside the mesh boundary.
+ const triIndex = mesh.triThatContainsPoint(point)
+
+ // 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)
+
+  // If we have permission to simulate sliding...
+  if (ENABLE_SLIDING) {
+
+   // Walk back the clock to before the ray hit.
+   time -= timeElapsedDuringThisIteration
+
+   const neighbor = {
+    dot: -Infinity,
+    point: null,
+    triIndex: null,
+    direction: {
+     x: null,
+     y: 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
+
+    // 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.y = null
+     } else {
+      boundaryAppearsFlat = false
+      neighbor.dot = dot
+      neighbor.point = point
+      neighbor.triIndex = triIndex
+      neighbor.direction = direction
+     }
+    }
+   }
+
+   if (boundaryAppearsFlat) {
+    // TODO: Consider using the line through the opposing neighbors to search for asymmetry in the mesh boundary.
+   }
+
+   // If there is no neighboring point, we are "stuck". The ray cast ends here.
+   if (!neighbor.point) {
+
+    // Return the safe result data.
+    safeIterationResult.hit = true
+    return safeIterationResult
+   }
+
+   // Compute travel distance to the center of the neighbor.
+   const vectorToNeighbor = Vector.subtract(neighbor.point, safeIterationResult.point)
+   const distance = Vector.magnitude(vectorToNeighbor)
+
+   // Construct a force vector pointing to the chosen neighbor.
+   // TODO: speed should actually be reduced.
+   const forceVectorToNeighbor = Vector.multiply(Vector.normalize(vectorToNeighbor), speed)
+
+   // Compute travel time to reach the neighbor.
+   timeElapsedDuringThisIteration = distance / speed
+
+   // Move the clock ahead to our arrival at the neighbor.
+   time += timeElapsedDuringThisIteration
+
+   // Check again if we ran out of time.
+   ranOutOfTime = time >= DELTA_TIME
+   if (ranOutOfTime) {
+    const overshootTime = time - DELTA_TIME
+    timeElapsedDuringThisIteration -= overshootTime
+    time = DELTA_TIME
+
+    // 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
+
+    if (triIndex === -1) {
+     // We didn't have enough time to overcome the diagonal boundary.
+
+     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
+     }
+
+     // 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
+     }
+
+     return safeIterationResult
+    } else {
+
+     // Go to the partial point.
+     safeIterationResult.point = point
+     safeIterationResult.triIndex = triIndex
+    }
+
+    return safeIterationResult
+
+    // TODO: Consider moving toward a 4-point neighbor instead.
+   }
+
+   // 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()
+
+   // Proceed with normal ray casting behavior from this point.
+   continue
+
+  } else {
+
+   // Discard the unsafe point and return the safe result data.
+   safeIterationResult.hit = true
+   return safeIterationResult
+  }
+ }
+
+
+ // Otherwise, update the safe result.
+ safeIterationResult.point = point
+ safeIterationResult.triIndex = triIndex
+
+ // If we ran out of time...
+ if (ranOutOfTime) {
+
+  // We're done. Return the safe point.
+  return safeIterationResult
+ }
+
+ // Otherwise, Prepare for the next grid line time of this dimension.
+ timeOfNextIntersection[dimension] += timeBetweenIntersections[dimension]
+}

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

@@ -0,0 +1,42 @@
+mesh.updateRouteID(ROUTE_ID)
+
+// Binary search better than embedded match.
+mesh.triIndex = (() => {
+
+ let low = 0
+ let high = mesh.triTable.length - 1
+
+ while (low <= high) {
+
+  const mid = (low + high) >>> 1
+  const triData = mesh.triTable[mid]
+  const nextTriData = mesh.triTable[mid + 1]
+
+  if (ROUTE_ID < triData.offset)
+   high = mid - 1
+  else if (nextTriData && ROUTE_ID >= nextTriData.offset)
+   low = mid + 1
+  else
+   return mid
+ }
+
+ // Fallback.
+ return 0
+})()
+
+ROUTE_ID -= mesh.triTable[mesh.triIndex].offset
+
+// Embedded match can become binary search later.
+for (const row of mesh.triTable[mesh.triIndex].rows) {
+
+ if (!row)
+  continue
+
+ const rowWidth = BigInt(row.range.max - row.range.min + 1)
+
+ if (ROUTE_ID < row.offset + rowWidth) {
+  mesh.position.y = row.y
+  mesh.position.x = row.range.min + Number(ROUTE_ID - row.offset)
+  break
+ }
+}

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

@@ -0,0 +1,5 @@
+// TODO: Validate MODEL and handle out-of-range points.
+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)

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

@@ -0,0 +1,95 @@
+declare interface IMesh<TOwner>
+ extends IPart<TOwner, null> {
+
+ // 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
+ /** 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
+
+ // Runtime Properties.
+ /** The memoization data of every tri in the mesh, stored by tri index at build-time. */
+ readonly triTable: IMeshTriData[]
+ /** 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 manifest: IMeshManifest
+}
+
+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. */
+  readonly min: number
+  /** The y position of the bottom-most row of the tri. */
+  readonly max: number
+ }
+ /** The rows of pixels in the tri. */
+ readonly rows: IMeshTriDataRow[]
+ /** The offset of the tri in the overall mesh. */
+ readonly offset: bigint
+ /** The total number of pixels in the tri. */
+ readonly cardinality: bigint
+}
+
+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 smallest x position that is within the tri row. */
+  readonly min: number
+  /** The largest x position that is within the tri row. */
+  readonly max: number
+ }
+ /** The bigint offset of this row in the overall tri. */
+ readonly offset: bigint
+}
+
+
+declare interface IMeshManifest
+ extends IPartManifest {
+ /** The available collision vertices as a flat array of 2D coordinates. Used for defining the world's collision tris. */
+ readonly points: number[],
+ /** The list of collision tris, as a flat array of point triples. Used to define the walkable area of the world. */
+ readonly tris: number[]
+}
+
+declare type IMeshData = [IMeshPoint[], IMeshTri[]]
+
+declare type IMeshTri =
+ [IMeshPointIndex, IMeshPointIndex, IMeshPointIndex]
+
+declare type IMeshPointIndex =
+ number
+
+declare type IMeshTriPoints =
+ [IMeshPoint, IMeshPoint, IMeshPoint]
+
+declare type IMeshPoint =
+ [x: number, y: number]
+
+declare type IMeshTriIndex =
+ number
+
+declare type IMeshAny =
+ IMesh<IPartAny>
+
+declare const mesh: IMeshAny
+
+declare const TRI: IMeshTriData

package/src/parts/abstract/mix/mathML-subpart.js

@@ -0,0 +1,9 @@
+const defaultTerm = /* xml */`<mn>1</mn>`
+
+if (DEPTH <= 0 || part.length === 0)
+ // Strip the "<math>" tags off.
+ return [mix.length ? /* xml */`<mo largeop="true">∏</mo><msub><mi>𝑘</mi><msub><mi>𝑝</mi><mi>${part.key ?? "ecosystem"}</mi></msub></msub>` : defaultTerm]
+
+const operator = "<mo class=product>&sdot;</mo>"
+const factors = part.map(subpart => subpart.mathML(DEPTH - 1, "none", LABELS, true, false)).filter(mathML => mathML !== defaultTerm && mathML !== `<mrow>${defaultTerm}</mrow>`)
+return factors.length ? factors.flatMap(factor => [factor, operator]).slice(0, -1) : [defaultTerm]

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

@@ -0,0 +1,3 @@
+const cardinality = part.cardinality
+const cardinalityAsString = instances.includes(part) ? cardinality.toString() : null
+return [cardinalityAsString.length < 16 ? `<mn>${cardinalityAsString}</mn>` : scientific(cardinality, true).slice(6, -7).split("<mo>&sdot;</mo>").flatMap(term => [term, "<mo>&sdot;</mo>"]).slice(0, -1)]

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

@@ -0,0 +1,22 @@
+const equationVariable = EQUATION_TYPE === "variable" || EQUATION_TYPE === "both" ? `${recurse(0, "none", false, false)}<mo>=</mo>` : ""
+const equationValue = EQUATION_TYPE === "value" || EQUATION_TYPE === "both" ? `<mo>=</mo>${part.cardinality.toString().length <= 15 ? `<mn>${part.cardinality}</mn>` : `<mrow>${scientific(part.cardinality, true).slice(6, -7)}</mrow>`}` : ""
+const expression = (() => {
+
+ if (DEPTH <= 0)
+  return `<msub><mi>𝑘</mi><mi>${part.key ?? "ecosystem"}</mi></msub>`
+
+ const terms = part.subpartMathML(DEPTH - 1, LABELS)
+
+ 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>` : "")
+})()
+
+// TODO: handle parenthesis!
+
+const showBracketBelow = DEPTH > 2
+
+return /* html */`${WRAP_IN_MATH_TAG ? "<math displaystyle=true><mrow>" : ""}${equationVariable}${expression}${equationValue}${WRAP_IN_MATH_TAG ? "</mrow></math>" : ""}`

package/src/parts/abstract/part/part.json

@@ -75,6 +75,17 @@
   ],
   "manifest-resolve-part-from": [
    "PROPERTY_KEY"
+  ],
+  "mathML": [
+   "DEPTH = 0",
+   "EQUATION_TYPE = \"none\"",
+   "LABELS = false",
+   "PARENTHESIZE = false",
+   "WRAP_IN_MATH_TAG = true"
+  ],
+  "mathML-subpart": [
+   "DEPTH",
+   "LABELS"
   ]
  }
 }

package/src/parts/abstract/part/routeID-update.js

@@ -1,14 +1,14 @@
 if (part.isAbstract)
- throw new Error(`You can't set the route ID of an abstract part. (${part.host})`)
+ throw new Error(`Route ID Update Error: You can't set the route ID of an abstract part. (${part.host})`)
 
 if (ROUTE_ID === undefined)
- throw new Error(`The ROUTE_ID argument is missing. ` + part.host)
+ throw new Error(`Route ID Update Error: The ROUTE_ID argument is missing. ` + part.host)
 
 if (typeof ROUTE_ID !== "bigint" || ROUTE_ID < -1n)
- throw new Error(`Route ID is invalid. ` + part.host)
+ throw new Error(`Route ID Update Error: Route ID is invalid. ` + part.host)
 
 if (ROUTE_ID >= part.cardinality)
- throw new Error(`Route ID (${ROUTE_ID}) out of range (max = ${part.cardinality - 1n}). ` + part.host)
+ throw new Error(`Route ID Update Error: Route ID (${ROUTE_ID}) out of range (max = ${part.cardinality - 1n}). ` + part.host)
 
 part.previousRouteID = part.routeID
 part.routeID = ROUTE_ID
@@ -20,6 +20,6 @@ part.justDisabled = !part.enabled && part.wasEnabled
 part.deltaRouteID = part.routeID - part.previousRouteID
 
 if (part.deltaRouteID === 0n)
- warn(`Reassigned route ID (${part.routeID}) to part.\n ${part[".."] ? `${part[".."].key} {\n  ${part.key} : "${part.host}" // <--- this part \n }` : part.host}`)
+ warn(`Route ID Update Warning: Reassigned route ID (${part.routeID}) to part.\n ${part[".."] ? `${part[".."].key} {\n  ${part.key} : "${part.host}" // <--- this part \n }` : part.host}`)
 
 part.dirty = true

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

@@ -109,6 +109,10 @@ declare interface IPart<TOwner, TSubpart>
  readonly resolveOwnerOfManifest(PROPERTY_KEY: string): IPartAny | null
  /** Returns a part whose host was provided as a (potentially relative) host name using the given property key in the part's manifest. This method uses the nearest part on which the manifest key is actually defined as the base for resolving any relative host name. Returns null if the given property does not exist anywhere in the chain. */
  readonly resolvePartFromManifest(PROPERTY_KEY: string): IPartAny | null
+ /** Generates a returns a MathML string that depicts the cardinality equation of the platform. @param DEPTH the number of levels deep to expand the terms of the equation (up to Infinity) @param AS_EQUATION when true, begins the expression with something like `<math><msub><mi>k</mi><mi>part key</mi></msub><mo>=</mo>...` @param PARENTHESIZE whether or not to add parenthesis around the expression (useful when it will be nested in a larger one) (they will only be added if the resulting expression is not a single term). */
+ readonly mathML(DEPTH: number = 0, EQUATION_TYPE: string = "none", LABELS: boolean = false, PARENTHESIZE: boolean = false, WRAP_IN_MATH_TAG: boolean = true): string
+ /** Returns an array of string terms and operators which, when joined, depict the part's cardinality collecting arithmetic. */
+ readonly subpartMathML(DEPTH: number, LABELS: boolean): string[]
 
  // Runtime Properties.
  /** The parent part.

package/src/parts/abstract/part-mask/mathML-subpart.js

@@ -0,0 +1 @@
+return [/* xml */`<msup><mn>2</mn><mn>${partMask.superset.length}</mn></msup>`]

package/src/parts/abstract/part-outliner/itemHTML-recursive.js

@@ -6,7 +6,7 @@ return partOutliner.getChildren(SUBJECT).map((childPart, i, childArray) => {
  const symbol = `<img src="${childPart.placeholderImage("part.png")}"/>`
  const handle = hasSubparts ? `<svg ${partOutliner.pointAttr("togglePoint", folderIndex)} xmlns="http://www.w3.org/2000/svg" viewBox="-1 -1 2 2" class="explore-toggle"><line x1="-0.41" y1="0" x2="0.41" y2="0" stroke-width="0.2" stroke-linecap="round" />${isOpen ? "" : `<line x1="0" y1="-0.41" x2="0" y2="0.41" stroke-width="0.2" stroke-linecap="round" />`}</svg>` : ""
  const label = `<span class="label${childPart.isAbstract ? " abstract" : ""}">${partOutliner.getLabel(childPart)}</span>`
- const summary = `<summary ${partOutliner.pointAttr("point", partIndex)} data-index="${partIndex}"${partOutliner.isActive(childPart) ? " data-active" : ""}${IS_LAST_OF_TYPE && !hasSubparts ? ' id="lastOutlinerItem"' : ""}>${Array(DEPTH + +!hasSubparts).fill('<outliner-spacer></outliner-spacer>').join("")}${handle}${symbol}${label}</summary>`
+ const summary = `<summary ${partOutliner.pointAttr("point", partIndex)} data-index="${partIndex}"${partOutliner.isActive(childPart) ? " data-active" : ""}${IS_LAST_OF_TYPE && !hasSubparts ? ' id="lastOutlinerItem"' : ""}><outliner-spacer style="--depth:${DEPTH + +!hasSubparts}"></outliner-spacer>${handle}${symbol}${label}</summary>`
  return `<details${hasSubparts ? "" : ` class=empty`} ${isOpen ? "open" : ""}>${summary}${recurse(childPart, DEPTH + 1, IS_LAST_OF_TYPE && i === childArray.length - 1)}</details>`
 }).join("")
 

package/src/parts/abstract/permutation/mathML-subpart.js

@@ -0,0 +1,10 @@
+const n = permutation.supersetSize
+
+// TODO: factor in other aspects when expanding to the collection type.
+
+return [
+ "<mn>1</mn>",
+ "<mo>+</mo>",
+ `<munderover><mo>∑</mo><mrow><mi>𝑛</mi><mo>=</mo><mn>1</mn></mrow><mi>${n}</mi></munderover>`,
+ `<munderover><mo>∏</mo><mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow><mrow><mi>𝑛</mi></mrow></munderover><mrow><mn>${permutation.payloadCardinality}</mn><mo>(</mo><mi>${n}</mi><mo>-</mo><mi>i</mi><mo>+</mo><mn>1</mn><mo>)</mo></mrow>`
+]

package/src/parts/abstract/scroller/mathML-subpart.js

@@ -0,0 +1 @@
+return [`<msup><mn>10</mn><mn>4</mn></msup>`]

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

@@ -1,4 +1,6 @@
-if (scroller.skipRouteIDUpdate) {
+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/hot-keys/async-install.js

@@ -37,6 +37,7 @@ globalThis.addEventListener("keyup", keyboardEvent => {
 })
 
 globalThis.addEventListener("keydown", keyboardEvent => {
+
  if (!keyboardEvent.repeat) {
   /* This handles the edge case when the user is holding modifier keys that
    * they pressed while not focused on this instance of the ecosystem. */
@@ -64,15 +65,24 @@ globalThis.addEventListener("keydown", keyboardEvent => {
 
   hotKeys.pressed.add(keyboardEvent.code)
 
-  const combo = hotKeys.combo
-  const methodName = JSON.parse(_.application["hot-keys.json"] ?? "{}")[combo] ?? hotKeys.table[combo]
-  const method = methodName && (_.application[methodName] ?? hotKeys[methodName])
+  const doCombo = () => {
+   const combo = hotKeys.combo
+   const methodName = JSON.parse(_.application["hot-keys.json"] ?? "{}")[combo] ?? hotKeys.table[combo]
+   const method = methodName && (_.application[methodName] ?? hotKeys[methodName])
 
-  if (methodName) {
-   keyboardEvent.preventDefault()
-   if (typeof method === "function")
-    method()
-   // else warn(`Hot Keys Warning: method called ${methodName} is not defined on either the hot keys manager or the current application.`)
+   if (methodName) {
+    keyboardEvent.preventDefault()
+    if (typeof method === "function")
+     method()
+    // else warn(`Hot Keys Warning: method called ${methodName} is not defined on either the hot keys manager or the current application.`)
+   }
   }
+
+  // Prevent a bug when the user presses keys too early.
+  if (client.hydrated)
+   doCombo()
+  else
+   client.promise.then(doCombo)
+
  }
 })

package/src/parts/core/hot-keys/constants.js

@@ -1,2 +1,4 @@
-const agent = _.parts.core.agent
-const hotKeys = this
+const hotKeys = this
+const core = hotKeys[".."]
+const agent = core.agent
+const client = core.client

package/src/parts/desktop/windows/superset-get.js

@@ -1 +1 @@
-return Object.values(_.applications)
+return Object.values(_.applications).filter(application => application !== _.parts.desktop)

package/src/{part.css → static.css}

@@ -30,7 +30,6 @@ body {
  --system-ui-mono: ui-monospace, Menlo, Monaco, "Cascadia Mono", "Segoe UI Mono", "Roboto Mono", "Oxygen Mono", "Ubuntu Mono", "Source Code Pro", "Fira Mono", "Droid Sans Mono", "Consolas", "Courier New", monospace;
  --menu-tween: 0;
  --h: 100vh;
- --warning-height: 28px;
  --wallpaper-height: calc(var(--h) - var(--task-bar-height) - var(--warning-height) - var(--title-bar-height));
  --wallpaper-width: 100vw;
  --padding: calc(3.5 * var(--spacing));
@@ -292,15 +291,6 @@ body.dark warning- {
  background-color: #644c08;
 }
 
-@media (width < 390px) {
-
- html,
- body {
-  --warning-height: 49px;
- }
-}
-
-
 #fullscreen-tray-item,
 #share-tray-item {
  display: none !important;

package/src/type.d.ts

@@ -283,7 +283,7 @@ declare function hydratePartsRecursive(part: string | IPartAny, domains: string[
 declare function resolveRelativeHost(relativeHost: string, base: string | string[]): string
 /** The immutable list of runtime instances for the root space, in order of when the were reached during recursive part hydration. */
 declare const instances: IPartAny[]
-/** The immutable list of every part in the root space, in order of when the were reached during recursive part hydration. */
+/** The immutable list of every part of the root space, in order of when the were reached during recursive part hydration. */
 declare const allParts: IPartAny[]
 /** The immutable list of every part host and filename combination, in order of when the were reached during recursive part hydration. */
 declare const allSubjects: [host: string, filename?: string]
@@ -308,6 +308,18 @@ declare class FenwickTree {
 declare class Vector {
  static magnitude(vector: IVector): number
  static normalize(vector: IVector): IVector
+ static sign(vector: IVector): IVector
+ static floor(vector: IVector): IVector
+ /** Performs the given binary operation on the two values, which can each be either a vector or a number. If at least one of the values is a vector, returns a vector. Otherwise, returns a number. */
+ static operate(value1: IVector | number, value2: IVector | number, operation: (a, b) => number): IVector | number
+ /** Adds the two values, which can each be either a vector or a number. If at least one of the values is a vector, returns a vector. Otherwise, returns a number. */
+ static add(value1: IVector | number, value2: IVector | number): IVector | number
+ /** Subtracts the two values, which can each be either a vector or a number. If at least one of the values is a vector, returns a vector. Otherwise, returns a number. */
+ static subtract(value1: IVector | number, value2: IVector | number): IVector | number
+ /** Multiplies the two values, which can each be either a vector or a number. If at least one of the values is a vector, returns a vector. Otherwise, returns a number. */
+ static multiply(value1: IVector | number, value2: IVector | number): IVector | number
+ static dot(vector1: IVector, vector2: IVector): number
 }
 
-declare type IVector = Record<string, number>
+declare type IVector = Record<string, number>
+declare type IVector2 = { x: number, y: number }