kireji 0.6.8 → 0.7.3

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "kireji",
- "version": "0.6.8",
+ "version": "0.7.3",
  "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/editor/point.js

@@ -163,7 +163,6 @@ const pointerConfig = {
      tabGroup.recomputeRouteID(true)
     } else {
 
-     debug("B", tabGroup.previewTabIndex === null, BigInt(tabGroup.openTabs.length), tabGroup.maxTabCount)
      if (BigInt(tabGroup.openTabs.length) === tabGroup.maxTabCount) {
       alert("You have too many tabs open!")
       return

package/src/build.js

@@ -90,6 +90,62 @@ function ƒ(_, compressedSubjectOrigins) {
      result[dimension] = vector[dimension] / magnitude
    return result
   }
+  static sign(vector) {
+   const result = {}
+   for (const dimension in vector)
+    result[dimension] = Math.sign(vector[dimension])
+   return result
+  }
+  static floor(vector) {
+   const result = {}
+   for (const dimension in vector)
+    result[dimension] = Math.floor(vector[dimension])
+   return result
+  }
+  static round(vector) {
+   const result = {}
+   for (const dimension in vector)
+    result[dimension] = Math.round(vector[dimension])
+   return result
+  }
+  static operate(value1, value2, operation) {
+   if (typeof value1 === "number" || typeof value2 === "number") {
+    if (typeof value1 === "number" && typeof value2 === "number")
+     return operation(value1, value2)
+
+    const result = {}
+    const number = typeof value1 === "number" ? value1 : value2
+    const vector = typeof value1 === "object" ? value1 : value2
+
+    for (const dimension in vector)
+     result[dimension] = operation(vector[dimension], number)
+
+    return result
+   }
+
+   const result = {}
+   const dimensions = Object.keys(value1)
+
+   if (dimensions.some(key => !(key in value2)) || Object.keys(value2).some(key => !(key in value1)))
+    throw new Error(`Vector Operation Error: the two vectors do not have the same keys.`)
+
+   for (const dimension of dimensions)
+    result[dimension] = operation(value1[dimension], value2[dimension])
+
+   return result
+  }
+  static add(value1, value2) {
+   return this.operate(value1, value2, (a, b) => a + b)
+  }
+  static subtract(value1, value2) {
+   return this.operate(value1, value2, (a, b) => a - b)
+  }
+  static multiply(value1, value2) {
+   return this.operate(value1, value2, (a, b) => a * b)
+  }
+  static dot(vector1, vector2) {
+   return vector1.x * vector2.x + vector1.y * vector2.y
+  }
  }
  class FenwickTree {
   static LSB = []

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

@@ -0,0 +1,84 @@
+mesh.define({
+ triTable: { value: [] },
+ triIndex: { value: -1, writable: true },
+ position: { value: { x: null, y: null } },
+ cardinality: {
+  resolve() {
+   let meshCardinality = 0n
+
+   // Obtain the raw data for this mesh.
+   const [pointList, tris] = mesh.getData()
+
+   // Iterate over each tri (array of three point indices) in the data.
+   for (const tri of tris) {
+
+    // Prepare the per-tri cardinality sum.
+    let triCardinality = 0n
+
+    // 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])
+
+    // Estimate the y-range of this tri.
+    const range = {
+     min: Math.min(...yPoints),
+     max: Math.max(...yPoints)
+    }
+
+    // Iterate over the range inclusively to populate each row subspace.
+    const rows = []
+    for (let rowID = range.min; rowID <= range.max; rowID++) {
+
+     // 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)
+
+     // Iterate over the 3 lines in order to determine where the edges intersect the given row.
+     const intersections = []
+     for (let edgeID = 0; edgeID < 3; edgeID++) {
+
+      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 (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
+      else throw new Error("Unexpected tri geometry found in mesh.")
+      continue
+     }
+
+     /** @type {IMeshTriDataRow} */
+     const row = {
+      y: rowID,
+      range: {
+       min: Math.ceil(Math.min(...intersections)),
+       max: Math.ceil(Math.max(...intersections)) - 1,
+      },
+      offset: triCardinality
+     }
+     rows.push(row)
+     triCardinality += BigInt(row.range.max - row.range.min + 1)
+    }
+
+    // Store the tri.
+    mesh.triTable.push({
+     points,
+     range,
+     rows,
+     offset: meshCardinality,
+     cardinality: triCardinality
+    })
+
+    meshCardinality += triCardinality
+   }
+
+   return meshCardinality
+  }
+ }
+})

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

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

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

@@ -0,0 +1 @@
+return { ...mesh.position }

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

@@ -0,0 +1,18 @@
+{
+ "abstract": true,
+ "methods": {
+  "data-get": [],
+  "point-tri-contains": [
+   "TRI_INDEX",
+   "POINT"
+  ],
+  "point-tri-that-contains": [
+   "POINT"
+  ],
+  "ray-cast": [
+   "FORCE_VECTOR",
+   "DELTA_TIME",
+   "ENABLE_SLIDING"
+  ]
+ }
+}

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

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

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

@@ -0,0 +1,10 @@
+// Check current tri first.
+if (mesh.triIndex !== -1 && mesh.triContainsPoint(mesh.triIndex, POINT))
+ return mesh.triIndex
+
+// Check all tris. TODO: Memoize neighbors.
+for (let triIndex = 0; triIndex < mesh.triTable.length; triIndex++)
+ if (triIndex !== mesh.triIndex && mesh.triContainsPoint(triIndex, POINT))
+  return triIndex
+
+return -1

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 initalizeRayIntersectionSchedule(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)
+ }
+}
+
+initalizeRayIntersectionSchedule(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 assymetry in the mesh boundry.
+   }
+
+   // 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.
+   initalizeRayIntersectionSchedule()
+
+   // 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,85 @@
+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
+}
+
+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 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/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/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/type.d.ts

@@ -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 }