velocious 1.0.461 → 1.0.463

package/src/http-server/websocket-channel-subscribers.js

@@ -92,12 +92,8 @@ export default class VelociousWebsocketChannelSubscribers {
       try {
         const result = callback(payload, meta)
 
-        if (result && typeof (/**
-                               * Narrows the runtime value to the documented type.
-                               * @type {Promise<void>} */ (result)).then === "function") {
-          tasks.push(/**
-                      * Narrows the runtime value to the documented type.
-                      * @type {Promise<void>} */ (result))
+        if (result && typeof (/** @type {Promise<void>} */ (result)).then === "function") {
+          tasks.push(/** @type {Promise<void>} */ (result))
         }
       } catch (error) {
         // Don't let one subscriber's failure abort the others; surface via the returned promises instead.

package/src/http-server/websocket-event-log-store.js

@@ -225,9 +225,7 @@ export default class VelociousHttpServerWebsocketEventLogStore {
         .order("sequence DESC")
         .limit(1)
         .results()
-      const row = /**
-                   * Narrows the runtime value to the documented type.
-                   * @type {Record<string, ?> | undefined} */ (rows[0])
+      const row = /** @type {Record<string, ?> | undefined} */ (rows[0])
 
       if (!row) return null
 
@@ -258,9 +256,7 @@ export default class VelociousHttpServerWebsocketEventLogStore {
         query.where(`sequence <= ${db.quote(upToSequence)}`)
       }
 
-      const rows = /**
-                    * Narrows the runtime value to the documented type.
-                    * @type {WebsocketEventRow[]} */ (await query.results())
+      const rows = /** @type {WebsocketEventRow[]} */ (await query.results())
 
       return rows.map((row) => this._normalizeEventRow(row))
     })
@@ -278,16 +274,12 @@ export default class VelociousHttpServerWebsocketEventLogStore {
     const cutoff = new Date(now.getTime() - this.retentionMs)
 
     await this._withDb(async (db) => {
-      const expiredEventRows = /**
-                                * Narrows the runtime value to the documented type.
-                                * @type {Array<{id: string}>} */ (await db
+      const expiredEventRows = /** @type {Array<{id: string}>} */ (await db
         .newQuery()
         .from(EVENTS_TABLE)
         .where(`created_at <= ${db.quote(cutoff)}`)
         .results())
-      const expiredReplayChannelRows = /**
-                                        * Narrows the runtime value to the documented type.
-                                        * @type {WebsocketReplayChannelRow[]} */ (await db
+      const expiredReplayChannelRows = /** @type {WebsocketReplayChannelRow[]} */ (await db
         .newQuery()
         .from(REPLAY_CHANNELS_TABLE)
         .where(`interested_until <= ${db.quote(now)}`)
@@ -365,9 +357,7 @@ export default class VelociousHttpServerWebsocketEventLogStore {
    * @returns {Promise<{channel: string, createdAt: string, id: string, payload: ?, sequence: number} | null>} - Event row or null.
    */
   async _getEventById({channel, db, id}) {
-    const rows = /**
-                  * Narrows the runtime value to the documented type.
-                  * @type {WebsocketEventRow[]} */ (await db
+    const rows = /** @type {WebsocketEventRow[]} */ (await db
       .newQuery()
       .from(EVENTS_TABLE)
       .where({channel, id})

package/src/http-server/websocket-events-host.js

@@ -43,9 +43,7 @@ export class VelociousHttpServerWebsocketEventsHost {
   publish(channelOrArgs, payloadArg) {
     const publishArgs = typeof channelOrArgs === "string"
       ? {channel: channelOrArgs, payload: payloadArg}
-      : /**
-         * Narrows the runtime value to the documented type.
-         * @type {{channel: string, payload: ?}} */ (channelOrArgs)
+      : /** @type {{channel: string, payload: ?}} */ (channelOrArgs)
     const channel = publishArgs.channel
     const payload = publishArgs.payload
 

package/src/http-server/worker-handler/in-process.js

@@ -28,9 +28,7 @@ export default class VelociousHttpServerInProcessHandler {
 
     this.logger = new Logger(this)
     this.workerCount = workerCount
-    this.unregisterFromEventsHost = websocketEventsHost.register(/**
-                                                                  * Narrows the runtime value to the documented type.
-                                                                  * @type {?} */ (this))
+    this.unregisterFromEventsHost = websocketEventsHost.register(/** @type {?} */ (this))
     this._stopping = false
   }
 
@@ -72,14 +70,8 @@ export default class VelociousHttpServerInProcessHandler {
 
     // Create a message-port shim so ServerClient.onSocketData can route data
     // to the in-process HTTP Client without needing a real worker thread.
-    const messagePortShim = /**
-                             * Narrows the runtime value to the documented type.
-                             * @type {import("worker_threads").Worker} */ (/**
-                                                                           * Narrows the runtime value to the documented type.
-                                                                           * @type {?} */ ({
-      postMessage: (/**
-                     * Narrows the runtime value to the documented type.
-                     * @type {{command: string, chunk?: Buffer | Uint8Array | string, clientCount?: number}} */ data) => {
+    const messagePortShim = /** @type {import("worker_threads").Worker} */ (/** @type {?} */ ({
+      postMessage: (/** @type {{command: string, chunk?: Buffer | Uint8Array | string, clientCount?: number}} */ data) => {
         if (data.command === "clientWrite" && data.chunk) {
           const chunk = typeof data.chunk === "string" ? Buffer.from(data.chunk) : Buffer.from(data.chunk)
 

package/src/http-server/worker-handler/index.js

@@ -1,8 +1,8 @@
 // @ts-check
 
+import {ensureError} from "typanic"
 import Logger from "../../logger.js"
 import {Worker} from "worker_threads"
-import ensureError from "../../utils/ensure-error.js"
 import websocketEventsHost from "../websocket-events-host.js"
 
 /**
@@ -109,7 +109,8 @@ export default class VelociousHttpServerWorker {
   onWorkerError = (error) => {
     this.logger.error(`Velocious worker ${this.workerCount} error`, error)
     void this._closeAllClients()
-    throw ensureError(error) // Throws original error with backtrace and everything into the console
+    // Preserve Error instances for the original backtrace while wrapping non-Error throwables.
+    throw ensureError(error)
   }
 
   /**

package/src/http-server/worker-handler/worker-thread.js

@@ -168,9 +168,7 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
 
     const {chunk, clientCount} = data
     if (!chunk) throw new Error("No chunk given")
-    const client = /**
-                    * Narrows the runtime value to the documented type.
-                    * @type {Client | undefined} */ (digg(this.clients, clientCount))
+    const client = /** @type {Client | undefined} */ (digg(this.clients, clientCount))
 
     if (!client) throw new Error(`Client not found for clientWrite: ${clientCount}`)
 

package/src/logger.js

@@ -196,9 +196,7 @@ function resolveLoggingOutputs({loggingConfiguration, configuration}) {
     for (const logger of loggingConfiguration.loggers) {
       if (!logger) continue
 
-      const loggerConfig = /**
-                            * Types the following value.
-                            * @type {?} */ (logger)
+      const loggerConfig = /** @type {?} */ (logger)
 
       if (typeof loggerConfig.toOutputConfig === "function") {
         loggerOutputs.push(loggerConfig.toOutputConfig({configuration}))
@@ -383,9 +381,7 @@ export default class Logger {
    */
   getConfiguration() {
     if (!this._configuration) {
-      const objectWithConfig = /**
-                                * Types the following value.
-                                * @type {{configuration?: import("./configuration.js").default}} */ (this._object)
+      const objectWithConfig = /** @type {{configuration?: import("./configuration.js").default}} */ (this._object)
       this._configuration = objectWithConfig?.configuration || currentConfiguration()
     }
 

package/src/mailer/backends/smtp.js

@@ -160,11 +160,7 @@ export default class SmtpMailerBackend {
       }
 
       const sendMessage = () => {
-        connection.send({from: envelopeFrom, to: recipients}, /**
-                                                               * Narrows the runtime value to the documented type.
-                                                               * @type {?} */ (message), (/**
-                                                                                          * Narrows the runtime value to the documented type.
-                                                                                          * @type {Error | null | undefined} */ sendError) => {
+        connection.send({from: envelopeFrom, to: recipients}, /** @type {?} */ (message), (/** @type {Error | null | undefined} */ sendError) => {
           if (sendError) {
             rejectDelivery(sendError)
             return

package/src/mailer/base.js

@@ -58,11 +58,7 @@ function inferActionName(mailerClass, stack) {
     if (frameActionName.startsWith("_")) continue
     if (frameActionName === "constructor") continue
     if (Object.prototype.hasOwnProperty.call(VelociousMailerBase.prototype, frameActionName)) continue
-    if (typeof /**
-                * Narrows the runtime value to the documented type.
-                * @type {Record<string, ?>} */ (/**
-                                                * Narrows the runtime value to the documented type.
-                                                * @type {?} */ (prototype))[frameActionName] !== "function") continue
+    if (typeof /** @type {Record<string, ?>} */ (/** @type {?} */ (prototype))[frameActionName] !== "function") continue
 
     actionName = frameActionName
   }
@@ -122,9 +118,7 @@ export class VelociousMailerBase {
   mail({to, subject, from, cc, bcc, replyTo, headers, actionName, actionPromise, ...restArgs}) {
     restArgsError(restArgs)
 
-    const resolvedActionName = actionName || inferActionName(/**
-                                                              * Narrows the runtime value to the documented type.
-                                                              * @type {typeof VelociousMailerBase} */ (this.constructor), new Error().stack || "")
+    const resolvedActionName = actionName || inferActionName(/** @type {typeof VelociousMailerBase} */ (this.constructor), new Error().stack || "")
 
     if (!resolvedActionName) {
       throw new Error(`Missing actionName for ${this.constructor.name}.mail()`)
@@ -215,19 +209,13 @@ export class VelociousMailerBase {
     const actionName = this._getActionName()
     const fileName = viewFileName(actionName)
     const viewPath = `${configuration.getDirectory()}/src/mailers/${mailerDir}/${fileName}.ejs`
-    const translate = (/**
-                        * Narrows the runtime value to the documented type.
-                        * @type {string} */ msgID, /**
-                                                   * Narrows the runtime value to the documented type.
-                                                   * @type {Record<string, ?> | undefined} */ args) => configuration.getTranslator()(msgID, args)
+    const translate = (/** @type {string} */ msgID, /** @type {Record<string, ?> | undefined} */ args) => configuration.getTranslator()(msgID, args)
     const viewParams = incorporate({mailer: this, _: translate}, this._viewParams)
 
     return await new Promise((resolve, reject) => {
       ejs.renderFile(viewPath, viewParams, {}, (err, str) => {
         if (err) {
-          const errorCode = /**
-                             * Narrows the runtime value to the documented type.
-                             * @type {{code?: string}} */ (err).code
+          const errorCode = /** @type {{code?: string}} */ (err).code
 
           if (errorCode === "ENOENT") {
             reject(new Error(`Missing mailer view file: ${viewPath}`))

package/src/plugins/sqljs-wasm-route-controller.js

@@ -52,9 +52,7 @@ export default class SqlJsWasmRouteController extends Controller {
     try {
       await fs.access(assetPath)
     } catch (error) {
-      const ensuredError = /**
-                            * Narrows the runtime value to the documented type.
-                            * @type {{code?: string}} */ (error)
+      const ensuredError = /** @type {{code?: string}} */ (error)
 
       if (ensuredError.code === "ENOENT") {
         await this.render({json: {errorMessage: "Not found", status: "error"}, status: "not-found"})

package/src/routes/basic-route.js

@@ -40,9 +40,7 @@ export default class VelociousBasicRoute extends BaseRoute {
       throw new Error("mount expects a mountable with a 'mountInto' method")
     }
 
-    const at = /**
-                * Narrows the runtime value to the documented type.
-                * @type {Record<string, ?>} */ (options).at
+    const at = /** @type {Record<string, ?>} */ (options).at
 
     if (typeof at !== "string" || !at.startsWith("/")) {
       throw new Error(`mount requires an 'at' option starting with '/', got: ${String(at)}`)

package/src/routes/resolver.js

@@ -4,9 +4,9 @@ import {dirname} from "path"
 import {fileURLToPath} from "url"
 import fs from "fs/promises"
 import * as inflection from "inflection"
+import {ensureError} from "typanic"
 import Logger from "../logger.js"
 import UploadedFile from "../http-server/client/uploaded-file/uploaded-file.js"
-import ensureError from "../utils/ensure-error.js"
 import toImportSpecifier from "../utils/to-import-specifier.js"
 
 /**
@@ -179,9 +179,7 @@ export default class VelociousRoutesResolver {
     }
 
     const controllerClass = await this.resolveControllerClass({controllerPath})
-    const controllerRequest = /**
-                               * Narrows the runtime value to the documented type.
-                               * @type {import("../http-server/client/request.js").default} */ (this.request)
+    const controllerRequest = /** @type {import("../http-server/client/request.js").default} */ (this.request)
     const controllerInstance = new controllerClass({
       action,
       configuration: this.configuration,
@@ -196,11 +194,7 @@ export default class VelociousRoutesResolver {
       throw new Error(`Missing action on controller: ${controller}#${action}`)
     }
 
-    const actionHandlers = /**
-                            * Narrows the runtime value to the documented type.
-                            * @type {Record<string, () => void | Promise<void>>} */ (/**
-                                                                                     * Narrows the runtime value to the documented type.
-                                                                                     * @type {?} */ (controllerInstance))
+    const actionHandlers = /** @type {Record<string, () => void | Promise<void>>} */ (/** @type {?} */ (controllerInstance))
 
     const logMethod = this._logMethod()
 
@@ -260,9 +254,7 @@ export default class VelociousRoutesResolver {
         stage: "controller-action"
       }
 
-      const errorWithContext = /**
-                                * Narrows the runtime value to the documented type.
-                                * @type {{velociousContext?: object}} */ (ensuredError)
+      const errorWithContext = /** @type {{velociousContext?: object}} */ (ensuredError)
 
       errorWithContext.velociousContext = {
         ...(errorWithContext.velociousContext || {}),
@@ -423,9 +415,7 @@ export default class VelociousRoutesResolver {
     const request = this.request
     const timestamp = this._formatTimestamp(new Date())
     const remoteAddress = request.remoteAddress() || "unknown"
-    const loggedParams = /**
-                          * Narrows the runtime value to the documented type.
-                          * @type {Record<string, ?>} */ (this._sanitizeParamsForLogging(this.params))
+    const loggedParams = /** @type {Record<string, ?>} */ (this._sanitizeParamsForLogging(this.params))
 
     delete loggedParams.action
     delete loggedParams.controller

package/src/testing/expect-utils.js

@@ -49,9 +49,7 @@ function isObjectLike(value) {
  * @returns {boolean} - Whether arrayContaining matcher.
  */
 function isArrayContaining(value) {
-  return !!value && typeof value === "object" && (/**
-                                                   * Narrows the runtime value to the documented type.
-                                                   * @type {?} */ (value)).__velociousMatcher === "arrayContaining"
+  return !!value && typeof value === "object" && (/** @type {?} */ (value)).__velociousMatcher === "arrayContaining"
 }
 
 /**
@@ -60,9 +58,7 @@ function isArrayContaining(value) {
  * @returns {boolean} - Whether objectContaining matcher.
  */
 function isObjectContaining(value) {
-  return !!value && typeof value === "object" && (/**
-                                                   * Narrows the runtime value to the documented type.
-                                                   * @type {?} */ (value)).__velociousMatcher === "objectContaining"
+  return !!value && typeof value === "object" && (/** @type {?} */ (value)).__velociousMatcher === "objectContaining"
 }
 
 /**
@@ -106,18 +102,12 @@ function valuesEqual(actual, expected) {
  */
 function collectMatchDifferences(actual, expected, path, differences) {
   if (isObjectContaining(expected)) {
-    collectMatchDifferences(actual, /**
-                                     * Narrows the runtime value to the documented type.
-                                     * @type {?} */ (expected).value, path, differences)
+    collectMatchDifferences(actual, /** @type {?} */ (expected).value, path, differences)
     return
   }
 
   if (isArrayContaining(expected)) {
-    const {matches} = matchArrayContaining(actual, /**
-                                                    * Narrows the runtime value to the documented type.
-                                                    * @type {Array<?>} */ (/**
-                                                                           * Narrows the runtime value to the documented type.
-                                                                           * @type {?} */ (expected).value))
+    const {matches} = matchArrayContaining(actual, /** @type {Array<?>} */ (/** @type {?} */ (expected).value))
 
     if (!matches) {
       differences[path || "$"] = [expected, actual]
@@ -146,12 +136,8 @@ function collectMatchDifferences(actual, expected, path, differences) {
       return
     }
 
-    const expectedObject = /**
-                            * Narrows the runtime value to the documented type.
-                            * @type {Record<string, ?>} */ (expected)
-    const actualObject = /**
-                          * Narrows the runtime value to the documented type.
-                          * @type {Record<string, ?>} */ (actual)
+    const expectedObject = /** @type {Record<string, ?>} */ (expected)
+    const actualObject = /** @type {Record<string, ?>} */ (actual)
 
     for (const key of Object.keys(expectedObject)) {
       const nextPath = path ? `${path}.${key}` : key
@@ -218,9 +204,7 @@ function matchArrayContaining(actual, expected) {
       if (usedIndexes.has(i)) continue
 
       if (isObjectContaining(expectedItem)) {
-        const {matches} = matchObject(actual[i], /**
-                                                  * Narrows the runtime value to the documented type.
-                                                  * @type {?} */ (expectedItem).value)
+        const {matches} = matchObject(actual[i], /** @type {?} */ (expectedItem).value)
         if (matches) {
           matchedIndex = i
           break
@@ -229,9 +213,7 @@ function matchArrayContaining(actual, expected) {
       }
 
       if (isArrayContaining(expectedItem)) {
-        const {matches} = matchArrayContaining(actual[i], /**
-                                                           * Narrows the runtime value to the documented type.
-                                                           * @type {?} */ (expectedItem).value)
+        const {matches} = matchArrayContaining(actual[i], /** @type {?} */ (expectedItem).value)
         if (matches) {
           matchedIndex = i
           break

package/src/testing/expect.js

@@ -454,9 +454,7 @@ export default class Expect extends BaseExpect {
     }
 
     if (isObjectContaining(result)) {
-      const expectedValue = /**
-                             * Narrows the runtime value to the documented type.
-                             * @type {?} */ (result).value
+      const expectedValue = /** @type {?} */ (result).value
       const {matches, differences} = matchObject(this._object, expectedValue)
       const objectPrint = formatValue(this._object)
       const expectedPrint = formatValue(expectedValue)
@@ -475,11 +473,7 @@ export default class Expect extends BaseExpect {
     }
 
     if (isArrayContaining(result)) {
-      const expectedValue = /**
-                             * Narrows the runtime value to the documented type.
-                             * @type {Array<?>} */ (/**
-                                                    * Narrows the runtime value to the documented type.
-                                                    * @type {?} */ (result).value)
+      const expectedValue = /** @type {Array<?>} */ (/** @type {?} */ (result).value)
       const {matches, differences} = matchArrayContaining(this._object, expectedValue)
       const objectPrint = formatValue(this._object)
       const expectedPrint = formatValue(expectedValue)
@@ -747,18 +741,14 @@ export default class Expect extends BaseExpect {
      * Differences.
      * @type {Record<string, Array<?>>} */
     const differences = {}
-    const objectAsRecord = /**
-                            * Narrows the runtime value to the documented type.
-                            * @type {Record<string, ?>} */ (this._object)
+    const objectAsRecord = /** @type {Record<string, ?>} */ (this._object)
 
     for (const key in result) {
       const value = result[key]
 
       if (!(key in objectAsRecord)) throw new Error(`${this._object.constructor.name} doesn't respond to ${key}`)
 
-      const objectValue = /**
-                           * Narrows the runtime value to the documented type.
-                           * @type {() => ?} */ (objectAsRecord[key])()
+      const objectValue = /** @type {() => ?} */ (objectAsRecord[key])()
 
       if (value != objectValue) {
         differences[key] = [value, objectValue]

package/src/testing/test-runner.js

@@ -378,9 +378,7 @@ export default class TestRunner {
   hasRunnableTests(tests, descriptions = [], lineMatchedInScope = false) {
     for (const testDescription in tests.tests) {
       const testData = tests.tests[testDescription]
-      const testArgs = /**
-                        * Narrows the runtime value to the documented type.
-                        * @type {TestArgs} */ (Object.assign({}, testData.args))
+      const testArgs = /** @type {TestArgs} */ (Object.assign({}, testData.args))
       const includeByLine = lineMatchedInScope || this.matchesLineFilter(testData)
 
       if (this._onlyFocussed && !testArgs.focus) continue
@@ -731,9 +729,7 @@ export default class TestRunner {
 
       for (const testDescription in tests.tests) {
         const testData = tests.tests[testDescription]
-        const testArgs = /**
-                          * Narrows the runtime value to the documented type.
-                          * @type {TestArgs} */ (Object.assign({}, testData.args))
+        const testArgs = /** @type {TestArgs} */ (Object.assign({}, testData.args))
         const includeByLine = scopeLineMatch || this.matchesLineFilter(testData)
 
         if (this._onlyFocussed && !testArgs.focus) continue
@@ -1126,9 +1122,7 @@ export default class TestRunner {
     /**
      * Console object.
      * @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */
-    const consoleObject = /**
-                           * Narrows the runtime value to the documented type.
-                           * @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */ (console)
+    const consoleObject = /** @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */ (console)
     /**
      * Original console methods.
      * @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */

package/src/testing/test.js

@@ -287,14 +287,10 @@ function it(description, arg1, arg2) {
   let testFunction
 
   if (typeof arg1 == "function") {
-    testFunction = /**
-                    * Narrows the runtime value to the documented type.
-                    * @type {() => (void|Promise<void>)} */ (arg1)
+    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)
     testArgs = {}
   } else if (typeof arg2 == "function") {
-    testFunction = /**
-                    * Narrows the runtime value to the documented type.
-                    * @type {() => (void|Promise<void>)} */ (arg2)
+    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)
     testArgs = arg1
   } else {
     throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)
@@ -331,14 +327,10 @@ function fit(description, arg1, arg2) {
   let testFunction
 
   if (typeof arg1 == "function") {
-    testFunction = /**
-                    * Narrows the runtime value to the documented type.
-                    * @type {() => (void|Promise<void>)} */ (arg1)
+    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)
     testArgs = {focus: true}
   } else if (typeof arg2 == "function") {
-    testFunction = /**
-                    * Narrows the runtime value to the documented type.
-                    * @type {() => (void|Promise<void>)} */ (arg2)
+    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)
     testArgs = Object.assign({focus: true}, arg1)
   } else {
     throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)

package/src/utils/model-scope.js

@@ -50,7 +50,5 @@ export function defineModelScope({callback, modelClass, startQuery}) {
  * @returns {value is ModelScopeDescriptor} - Whether the value is a scope descriptor.
  */
 export function isModelScopeDescriptor(value) {
-  return Boolean(value && typeof value === "object" && /**
-                                                        * Narrows the runtime value to the documented type.
-                                                        * @type {Record<string, ?>} */ (value)[MODEL_SCOPE_DESCRIPTOR_MARKER] === true)
+  return Boolean(value && typeof value === "object" && /** @type {Record<string, ?>} */ (value)[MODEL_SCOPE_DESCRIPTOR_MARKER] === true)
 }

package/src/utils/ransack.js

@@ -172,9 +172,7 @@ function normalizeAdvancedRansackConditions({modelClass, value}) {
       throw new Error(`Unsupported ransack predicate in condition: ${predicateValue}`)
     }
 
-    const predicate = /**
-                       * Narrows the runtime value to the documented type.
-                       * @type {RansackPredicate} */ (predicateValue)
+    const predicate = /** @type {RansackPredicate} */ (predicateValue)
     const rawValue = advancedRansackConditionValue({predicate, value: entry.v})
     const normalizedValue = normalizeRansackValue({predicate, value: rawValue})
 
@@ -523,18 +521,12 @@ function resolveAttributeName({modelClass, value}) {
  * @returns {Record<string, {targetModelClass: RansackModelClass}>} - Relationship entries keyed by name.
  */
 function relationshipEntries(modelClass) {
-  if (typeof /**
-              * Narrows the runtime value to the documented type.
-              * @type {?} */ (modelClass).getRelationshipsMap === "function") {
+  if (typeof /** @type {?} */ (modelClass).getRelationshipsMap === "function") {
     return backendRelationshipEntries(modelClass)
   }
 
-  if (typeof /**
-              * Narrows the runtime value to the documented type.
-              * @type {?} */ (modelClass).relationshipDefinitions === "function" &&
-    typeof /**
-            * Narrows the runtime value to the documented type.
-            * @type {?} */ (modelClass).relationshipModelClasses === "function") {
+  if (typeof /** @type {?} */ (modelClass).relationshipDefinitions === "function" &&
+    typeof /** @type {?} */ (modelClass).relationshipModelClasses === "function") {
     return frontendRelationshipEntries(modelClass)
   }
 
@@ -551,9 +543,7 @@ function backendRelationshipEntries(modelClass) {
    * Entries.
    * @type {Record<string, {targetModelClass: RansackModelClass}>} */
   const entries = {}
-  const relationshipsMap = /**
-                            * Narrows the runtime value to the documented type.
-                            * @type {?} */ (modelClass).getRelationshipsMap()
+  const relationshipsMap = /** @type {?} */ (modelClass).getRelationshipsMap()
 
   for (const relationshipName of Object.keys(relationshipsMap)) {
     const relationship = relationshipsMap[relationshipName]
@@ -580,12 +570,8 @@ function frontendRelationshipEntries(modelClass) {
    * Entries.
    * @type {Record<string, {targetModelClass: RansackModelClass}>} */
   const entries = {}
-  const definitions = /**
-                       * Narrows the runtime value to the documented type.
-                       * @type {?} */ (modelClass).relationshipDefinitions()
-  const relationshipModelClasses = /**
-                                    * Narrows the runtime value to the documented type.
-                                    * @type {?} */ (modelClass).relationshipModelClasses()
+  const definitions = /** @type {?} */ (modelClass).relationshipDefinitions()
+  const relationshipModelClasses = /** @type {?} */ (modelClass).relationshipModelClasses()
 
   for (const relationshipName of Object.keys(definitions)) {
     const targetModelClass = resolveFrontendModelClass(relationshipModelClasses[relationshipName])
@@ -604,20 +590,12 @@ function frontendRelationshipEntries(modelClass) {
  * @returns {Record<string, string>} - Attribute-to-column entries keyed by attribute name.
  */
 function attributeEntries(modelClass) {
-  if (typeof /**
-              * Narrows the runtime value to the documented type.
-              * @type {?} */ (modelClass).getAttributeNameToColumnNameMap === "function") {
-    return /** @type {Record<string, string>} */ ((/**
-                                                    * Narrows the runtime value to the documented type.
-                                                    * @type {?} */ (modelClass).getAttributeNameToColumnNameMap()))
-  }
-
-  const resourceConfig = typeof /**
-                                 * Narrows the runtime value to the documented type.
-                                 * @type {?} */ (modelClass).resourceConfig === "function"
-    ? /**
-       * Narrows the runtime value to the documented type.
-       * @type {?} */ (modelClass).resourceConfig()
+  if (typeof /** @type {?} */ (modelClass).getAttributeNameToColumnNameMap === "function") {
+    return /** @type {Record<string, string>} */ ((/** @type {?} */ (modelClass).getAttributeNameToColumnNameMap()))
+  }
+
+  const resourceConfig = typeof /** @type {?} */ (modelClass).resourceConfig === "function"
+    ? /** @type {?} */ (modelClass).resourceConfig()
     : {}
   const attributes = resourceConfig.attributes
   /**
@@ -675,9 +653,7 @@ function parseRansackKey(key) {
 
     return {
       pathValue,
-      predicate: /**
-                  * Narrows the runtime value to the documented type.
-                  * @type {RansackPredicate} */ (predicate)
+      predicate: /** @type {RansackPredicate} */ (predicate)
     }
   }
 
@@ -694,9 +670,7 @@ function parseRansackKey(key) {
 
     return {
       pathValue,
-      predicate: /**
-                  * Narrows the runtime value to the documented type.
-                  * @type {RansackPredicate} */ (predicate)
+      predicate: /** @type {RansackPredicate} */ (predicate)
     }
   }
 

package/src/utils/with-tracked-stack-async-hooks.js

@@ -10,9 +10,7 @@ let asyncLocalStorage
 /**
  * Tracked stack global.
  * @type {{withTrackedStack?: {addTrackedStackToError: (error: Error) => void, withTrackedStack: (arg1: string | (() => Promise<?>), arg2?: (() => Promise<?>) | Error) => Promise<?>}}} */
-const trackedStackGlobal = /**
-                            * Narrows the runtime value to the documented type.
-                            * @type {?} */ (globalThis)
+const trackedStackGlobal = /** @type {?} */ (globalThis)
 
 if (AsyncLocalStorage) {
   asyncLocalStorage = new AsyncLocalStorage()
@@ -57,14 +55,10 @@ async function withTrackedStack(arg1, arg2) {
   let stack
 
   if (typeof arg2 == "function" && typeof arg1 == "string") {
-    callback = /**
-                * Narrows the runtime value to the documented type.
-                * @type {() => Promise<?>} */ (arg2)
+    callback = /** @type {() => Promise<?>} */ (arg2)
     stack = arg1
   } else {
-    callback = /**
-                * Narrows the runtime value to the documented type.
-                * @type {() => Promise<?>} */ (arg1)
+    callback = /** @type {() => Promise<?>} */ (arg1)
     stack = Error().stack || ""
   }