@kudzujs/core 0.8.61 → 0.9.0

package/framework/compiler/outside-click-pass.mjs

@@ -0,0 +1,79 @@
+import ts from "typescript"
+import { isUnshadowedGlobal, unwrapExpression } from "./ast-helpers.mjs"
+
+const valueName = "__kOutsideClickValue"
+
+export function analyzeOutsideClickHook(hook) {
+  if (!hook || hook.asteriskToken || hook.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword) || !ts.isBlock(hook.body) || hook.body.statements.length !== 1) return undefined
+  if (!frameworkImport(hook.getSourceFile(), "useEffect")) return undefined
+  const normalized = hook.parameters.length === 3 && ts.isIdentifier(hook.parameters[2].name) && hook.parameters[2].name.text === valueName
+  if (!normalized && hook.parameters.length !== 2) return undefined
+  const [refParameter, callbackParameter] = hook.parameters
+  if (!ts.isIdentifier(refParameter?.name) || refParameter.initializer || refParameter.dotDotDotToken || !ts.isIdentifier(callbackParameter?.name) || callbackParameter.initializer || callbackParameter.dotDotDotToken) return undefined
+  const statement = hook.body.statements[0]
+  if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression) || !ts.isIdentifier(statement.expression.expression) || statement.expression.expression.text !== "useEffect" || statement.expression.arguments.length !== 2) return undefined
+  const [setup, dependencies] = statement.expression.arguments
+  if ((!ts.isArrowFunction(setup) && !ts.isFunctionExpression(setup)) || setup.parameters.length || setup.asteriskToken || setup.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword) || !ts.isBlock(setup.body) || setup.body.statements.length !== 3 || !ts.isArrayLiteralExpression(dependencies)) return undefined
+  const sourceDependencies = dependencies.elements.length === 2 && ts.isIdentifier(dependencies.elements[0]) && dependencies.elements[0].text === refParameter.name.text && ts.isIdentifier(dependencies.elements[1]) && dependencies.elements[1].text === callbackParameter.name.text
+  if (normalized ? dependencies.elements.length !== 0 : !sourceDependencies) return undefined
+  const [handlerStatement, addStatement, cleanupStatement] = setup.body.statements
+  if (!ts.isFunctionDeclaration(handlerStatement) || handlerStatement.asteriskToken || handlerStatement.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword) || !handlerStatement.name || handlerStatement.parameters.length !== 1 || !ts.isIdentifier(handlerStatement.parameters[0].name) || !handlerStatement.body || handlerStatement.body.statements.length !== 1) return undefined
+  const event = handlerStatement.parameters[0].name.text
+  const condition = handlerStatement.body.statements[0]
+  if (!ts.isIfStatement(condition) || condition.elseStatement || !ts.isBlock(condition.thenStatement) || condition.thenStatement.statements.length !== 1 || !outsideCondition(condition.expression, refParameter.name.text, event)) return undefined
+  const callbackStatement = condition.thenStatement.statements[0]
+  if (!ts.isExpressionStatement(callbackStatement) || !ts.isCallExpression(callbackStatement.expression) || !ts.isIdentifier(callbackStatement.expression.expression) || callbackStatement.expression.expression.text !== callbackParameter.name.text) return undefined
+  if (normalized ? callbackStatement.expression.arguments.length !== 1 || !ts.isIdentifier(callbackStatement.expression.arguments[0]) || callbackStatement.expression.arguments[0].text !== valueName : callbackStatement.expression.arguments.length) return undefined
+  if (!listenerStatement(addStatement, "addEventListener", handlerStatement.name.text, hook.getSourceFile())) return undefined
+  const cleanup = ts.isReturnStatement(cleanupStatement) && cleanupStatement.expression && (ts.isArrowFunction(cleanupStatement.expression) || ts.isFunctionExpression(cleanupStatement.expression)) ? cleanupStatement.expression : undefined
+  const cleanupBody = cleanup && ts.isBlock(cleanup.body) && cleanup.body.statements.length === 1 ? cleanup.body.statements[0] : undefined
+  if (!cleanup || cleanup.parameters.length || cleanup.asteriskToken || cleanup.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword) || !listenerStatement(cleanupBody, "removeEventListener", handlerStatement.name.text, hook.getSourceFile())) return undefined
+  return { callbackCall: callbackStatement.expression, dependencies, normalized, valueName }
+}
+
+export function normalizeOutsideClickHooks(sourceFile, factory, context) {
+  const visitor = node => {
+    if (ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+      const hook = analyzeOutsideClickHook(node)
+      if (hook && !hook.normalized) {
+        const rewrite = current => {
+          if (current === hook.callbackCall) return factory.updateCallExpression(current, current.expression, current.typeArguments, [factory.createIdentifier(valueName)])
+          if (current === hook.dependencies) return factory.updateArrayLiteralExpression(current, [])
+          return ts.visitEachChild(current, rewrite, context)
+        }
+        return updateFunction(node, [...node.parameters, factory.createParameterDeclaration(undefined, undefined, valueName)], ts.visitEachChild(node.body, rewrite, context), factory)
+      }
+    }
+    return ts.visitEachChild(node, visitor, context)
+  }
+  return ts.visitNode(sourceFile, visitor)
+}
+
+function updateFunction(node, parameters, body, factory) {
+  if (ts.isFunctionDeclaration(node)) return factory.updateFunctionDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, parameters, node.type, body)
+  if (ts.isFunctionExpression(node)) return factory.updateFunctionExpression(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, parameters, node.type, body)
+  return factory.updateArrowFunction(node, node.modifiers, node.typeParameters, parameters, node.type, node.equalsGreaterThanToken, body)
+}
+
+function outsideCondition(node, ref, event) {
+  node = unwrapExpression(node)
+  if (!ts.isBinaryExpression(node) || node.operatorToken.kind !== ts.SyntaxKind.AmpersandAmpersandToken || !currentAccess(unwrapExpression(node.left), ref)) return false
+  const right = unwrapExpression(node.right)
+  if (!ts.isPrefixUnaryExpression(right) || right.operator !== ts.SyntaxKind.ExclamationToken) return false
+  const contains = unwrapExpression(right.operand)
+  return ts.isCallExpression(contains) && contains.arguments.length === 1 && ts.isPropertyAccessExpression(contains.expression) && contains.expression.name.text === "contains" && currentAccess(unwrapExpression(contains.expression.expression), ref) && ts.isPropertyAccessExpression(unwrapExpression(contains.arguments[0])) && ts.isIdentifier(unwrapExpression(contains.arguments[0]).expression) && unwrapExpression(contains.arguments[0]).expression.text === event && unwrapExpression(contains.arguments[0]).name.text === "target"
+}
+
+function currentAccess(node, ref) {
+  return ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === ref && node.name.text === "current"
+}
+
+function listenerStatement(statement, method, handler, sourceFile) {
+  if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression) || statement.expression.arguments.length !== 2 || !ts.isStringLiteral(statement.expression.arguments[0]) || statement.expression.arguments[0].text !== "mousedown" || !ts.isIdentifier(statement.expression.arguments[1]) || statement.expression.arguments[1].text !== handler || !ts.isPropertyAccessExpression(statement.expression.expression)) return false
+  const target = statement.expression.expression.expression
+  return ts.isIdentifier(target) && target.text === "document" && isUnshadowedGlobal(target, sourceFile) && statement.expression.expression.name.text === method
+}
+
+function frameworkImport(sourceFile, name) {
+  return sourceFile.statements.some(statement => ts.isImportDeclaration(statement) && !statement.importClause?.isTypeOnly && ts.isStringLiteral(statement.moduleSpecifier) && ["react", "@kudzujs/core"].includes(statement.moduleSpecifier.text) && statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause.namedBindings) && statement.importClause.namedBindings.elements.some(entry => !entry.isTypeOnly && !entry.propertyName && entry.name.text === name))
+}

package/framework/compiler/react-migration-pass.mjs

@@ -5,7 +5,7 @@ import { analyzeCollectionPipeline, isArrayFromCall } from "./collection-analysi
 export function createReactMigrationPass({ cloneAst, jsxTagName }) {
   function normalizeReactMigrationSyntax(sourceFile, factory, context, importedCollections = new Set()) {
     const supported = new Set(["createContext", "useContext", "useEffect", "useId", "useReducer", "useRef", "useState"])
-    const erased = new Set(["forwardRef", "memo", "useCallback", "useMemo"])
+    const erased = new Set(["createRef", "forwardRef", "memo", "useCallback", "useMemo"])
     const aliases = new Map()
     const reactObjects = new Set()
     for (const statement of sourceFile.statements) {
@@ -110,6 +110,15 @@ export function createReactMigrationPass({ cloneAst, jsxTagName }) {
       }
       if (ts.isCallExpression(node)) {
         const name = migrationCallName(node)
+        if (name === "createRef") {
+          const declaration = node.parent
+          const owner = ts.isVariableDeclaration(declaration) && nearestFunction(declaration)
+          if (!ts.isVariableDeclaration(declaration) || declaration.initializer !== node || !ts.isIdentifier(declaration.name) || !isLocalConst(declaration) || !owner) throw sourceNodeError(node, sourceFile, "React createRef() must initialize one top-level const identifier in a component")
+          if (node.arguments.length) throw sourceNodeError(node, sourceFile, "React createRef() does not accept runtime arguments")
+          if (!hasOneIntrinsicRef(owner, declaration.name.text)) throw sourceNodeError(declaration, sourceFile, "React createRef() must be attached exactly once to an intrinsic element")
+          required.add("useRef")
+          return factory.createCallExpression(factory.createIdentifier("useRef"), node.typeArguments, [factory.createNull()])
+        }
         if (name === "forwardRef") return ts.visitNode(lowerReactForwardRef(node, sourceFile, factory), visitor)
         if (name === "memo") {
           if (node.arguments.length !== 1 || !(ts.isArrowFunction(node.arguments[0]) || ts.isFunctionExpression(node.arguments[0]) || ts.isIdentifier(node.arguments[0]))) throw sourceNodeError(node, sourceFile, "React memo() requires exactly one function component or component identifier")
@@ -251,6 +260,23 @@ export function createReactMigrationPass({ cloneAst, jsxTagName }) {
       : factory.updateFunctionExpression(callback, callback.modifiers, undefined, callback.name, callback.typeParameters, [parameter], callback.type, callback.body)
   }
 
+  function hasOneIntrinsicRef(owner, name) {
+    let attachments = 0
+    let intrinsic = 0
+    const visit = node => {
+      if (node !== owner && isFunctionLike(node)) return
+      if (ts.isJsxAttribute(node) && node.name.text === "ref" && node.initializer && ts.isJsxExpression(node.initializer) && ts.isIdentifier(node.initializer.expression) && node.initializer.expression.text === name) {
+        attachments++
+        const element = node.parent?.parent
+        const tag = ts.isJsxOpeningElement(element) || ts.isJsxSelfClosingElement(element) ? element.tagName : undefined
+        if (ts.isIdentifier(tag) && tag.text[0] === tag.text[0].toLowerCase()) intrinsic++
+      }
+      ts.forEachChild(node, visit)
+    }
+    visit(owner.body)
+    return attachments === 1 && intrinsic === 1
+  }
+
   function validateUseIdSyntax(sourceFile) {
     const imported = sourceFile.statements.some(statement => ts.isImportDeclaration(statement) && ["@kudzujs/core", "react"].includes(statement.moduleSpecifier.text) && statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause.namedBindings) && statement.importClause.namedBindings.elements.some(entry => !entry.propertyName && entry.name.text === "useId"))
     if (!imported) return

package/framework/compiler/route-artifact-report.mjs

@@ -18,7 +18,8 @@ export function createRouteArtifactReport(records, {
   if (!runtimeFamilies || !runtimeFamilyByRecord) ({ families: runtimeFamilies, familyByRecord: runtimeFamilyByRecord } = planRuntimeFamilies(records))
   const handlerGraph = handlerMetafile ? outputGraph(handlerMetafile, outputDirectory, base) : new Map()
   const routes = records.map(record => {
-    const capability = planRouteCapabilities([record], { navigationRouteCount: Number(record.capabilities.navigable) })
+    const family = runtimeFamilyByRecord.get(record)
+    const capability = family && !family.navigation ? family.capability : planRouteCapabilities([record], { navigationRouteCount: Number(record.capabilities.navigable) })
     const handlerEntries = [...new Set(record.artifacts.handlers.map(reference => reference.module))].sort()
     const handlerOutputs = closure(handlerEntries, handlerGraph, Boolean(handlerMetafile))
     const workers = workerReferences
@@ -35,7 +36,7 @@ export function createRouteArtifactReport(records, {
         signature: capabilitySignature(capability),
         manifest: capability
       },
-      runtime: routeRuntimeEdges(record, capability, runtimeFamilyByRecord.get(record), base, navigationAssets.get(record.route)),
+      runtime: routeRuntimeEdges(record, capability, family, base, navigationAssets.get(record.route)),
       handlers: {
         entries: handlerEntries,
         chunks: handlerOutputs.filter(output => !handlerEntries.includes(output))
@@ -58,7 +59,7 @@ export function createRouteArtifactReport(records, {
       id: family.id,
       signature: family.signature,
       navigation: family.navigation,
-      routes: records.filter(record => runtimeFamilyByRecord.get(record)?.id === family.id).map(record => record.route).sort(),
+      routes: family.records.map(record => record.route).sort(),
       manifest: family.capability,
       requirements: familyRuntimeRequirements(family, base)
     })),

package/framework/compiler/route-build-record.mjs

@@ -1,6 +1,7 @@
 import { assertJsonSafe, assertRouteIR } from "./route-ir.mjs"
 
 const validated = new WeakSet()
+const releasedPlans = new WeakSet()
 
 export function createRouteBuildRecord(input) {
   const record = {
@@ -22,6 +23,10 @@ export function createRouteBuildRecord(input) {
 }
 
 export function assertRouteBuildRecord(record) {
+  if (releasedPlans.has(record)) {
+    if (record.plan !== undefined) throw new Error("Released RouteBuildRecord plan was restored")
+    return record
+  }
   if (validated.has(record)) return record
   if (record?.version !== 1) throw new Error(`Unsupported RouteBuildRecord version: ${JSON.stringify(record?.version)}`)
   if (typeof record.route !== "string" || typeof record.output !== "string" || typeof record.html !== "string" || !isRecord(record.plan)) throw new Error("Invalid RouteBuildRecord v1 structure")
@@ -60,6 +65,13 @@ export function assertRouteBuildRecord(record) {
   return record
 }
 
+export function releaseRouteBuildRecordPlan(record) {
+  assertRouteBuildRecord(record)
+  record.plan = undefined
+  releasedPlans.add(record)
+  return record
+}
+
 export function planRouteArtifacts(records, handlerModules, workerReferences, moduleUrl) {
   for (const record of records) assertRouteBuildRecord(record)
   const modules = new Map()

package/framework/compiler/route-capability-planner.mjs

@@ -1,8 +1,8 @@
 import { assertRouteBuildRecord } from "./route-build-record.mjs"
 import { assertJsonSafe, assertRouteIR } from "./route-ir.mjs"
 
-export function usesRouteDependencyRuntime({ plan, navigable, hasBindings, hasLists }) {
-  assertRouteIR(plan)
+export function usesRouteDependencyRuntime({ plan, navigable, hasBindings, hasLists }, validate = true) {
+  if (validate) assertRouteIR(plan)
   const hasDependencies = plan.effects.some(effect => effect.dependencies?.length)
   return !navigable && hasDependencies && !plan.effects.some(effect => effect.owner) && !hasBindings && !hasLists && !plan.events.some(event => event.native)
 }
@@ -109,7 +109,7 @@ export function planRouteCapabilities(records, { navigationRouteCount = 0 } = {}
       dependency: routeEntries.some(route => route.usesDependencyRuntime)
     }
   }
-  return validate ? assertCapabilityIR(capabilityIR, records, { navigationRouteCount }) : capabilityIR
+  return validate ? assertCapabilityIR(capabilityIR) : capabilityIR
 }
 
 export function assertCapabilityIR(capabilityIR, records, options = {}) {

package/framework/compiler/route-ir.mjs

@@ -1,5 +1,6 @@
 const markerFields = new Set(["cleanup", "list", "svg", "mount", "static", "indexed", "reducer", "nested", "effects", "conditions", "conditionHandlers", "textRanges", "attributes", "events", "expressions", "expressionAttributes", "fastRelease"])
 const validated = new WeakSet()
+const jsonSafe = new WeakSet()
 
 export function assertRouteIR(plan, { concrete = false } = {}) {
   if (validated.has(plan) && (!concrete || typeof plan.route === "string")) return plan
@@ -62,7 +63,7 @@ export function assertRouteIR(plan, { concrete = false } = {}) {
 function assertEvent(event, index, ids) {
   if (!isRecord(event) || !nonempty(event.event) || event.commands === undefined && event.native === undefined) throw new Error(`Invalid RouteIR v1 event at index ${index}`)
   for (const command of event.commands ?? []) {
-    if (!Array.isArray(command) || command.length !== 3 || !["set", "add", "log"].includes(command[0])) throw new Error(`RouteIR event ${index} command has unsupported operation ${JSON.stringify(command?.[0])}`)
+    if (!Array.isArray(command) || command.length !== 3 || !["set", "add", "toggle", "log"].includes(command[0])) throw new Error(`RouteIR event ${index} command has unsupported operation ${JSON.stringify(command?.[0])}`)
     if (!ids.has(command[1]) && !rowTemplate(command[1])) throw new Error(`RouteIR event ${index} command references missing state ${JSON.stringify(command[1])}`)
     if (command[0] === "add" && (typeof command[2] !== "number" || !Number.isFinite(command[2]))) throw new Error(`RouteIR event ${index} add command requires a finite number`)
   }
@@ -76,6 +77,13 @@ function assertEffect(effect, index, ids, lists) {
   if (new Set(effect.dependencies ?? []).size !== (effect.dependencies ?? []).length) throw new Error(`${label} has duplicate dependencies`)
   for (const state of Object.values(effect.dependencyStates ?? {})) if (!ids.has(state) && !rowTemplate(state)) throw new Error(`${label} derived dependency references missing state ${JSON.stringify(state)}`)
   if (effect.dependencyExpressions !== undefined && !Array.isArray(effect.dependencyExpressions) || effect.itemDependencies !== undefined && (!Array.isArray(effect.itemDependencies) || effect.itemDependencies.some(field => !nonempty(field)))) throw new Error(`${label} has invalid dependencies`)
+  if (effect.dependencyEvaluators !== undefined) {
+    if (!Array.isArray(effect.dependencyEvaluators) || !effect.dependencyEvaluators.length) throw new Error(`${label} has invalid calculation dependency evaluators`)
+    for (const [dependencyIndex, evaluator] of effect.dependencyEvaluators.entries()) {
+      assertReactiveDescriptor(evaluator, `${label} calculation dependency ${dependencyIndex}`, ids)
+      if (!nonempty(evaluator.field) || ["__proto__", "constructor", "prototype"].includes(evaluator.field)) throw new Error(`${label} calculation dependency ${dependencyIndex} has invalid field`)
+    }
+  }
   if (effect.itemDependencies?.length) {
     if (!nonempty(effect.listState) || !lists.some(list => list.state === effect.listState) || !effect.owner) throw new Error(`${label} item dependencies require a matching owned list`)
   }
@@ -165,30 +173,38 @@ function validSeed(seed) {
 }
 
 export function assertJsonSafe(value, label = "Value") {
-  const invalid = invalidJsonPath(value, new Set(), "$")
+  const invalid = invalidJsonPath(value, new Set(), jsonSafe, [])
   if (invalid) throw new Error(`${label} is not JSON-safe at ${invalid}`)
   return value
 }
 
-function invalidJsonPath(value, seen, path) {
+function invalidJsonPath(value, seen, safe, path) {
   if (value === null || typeof value === "string" || typeof value === "boolean") return undefined
-  if (typeof value === "number") return Number.isFinite(value) && !Object.is(value, -0) ? undefined : path
-  if (!value || typeof value !== "object" || seen.has(value) || Object.getOwnPropertySymbols(value).length) return path
+  if (typeof value === "number") return Number.isFinite(value) && !Object.is(value, -0) ? undefined : jsonPath(path)
+  if (!value || typeof value !== "object" || seen.has(value)) return jsonPath(path)
+  if (safe.has(value)) return undefined
   const prototype = Object.getPrototypeOf(value)
-  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) return path
-  const descriptors = Object.getOwnPropertyDescriptors(value)
-  if (Array.isArray(value) && (Object.keys(descriptors).some(key => key !== "length" && !/^(0|[1-9]\d*)$/.test(key)) || Object.keys(value).length !== value.length)) return path
+  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) return jsonPath(path)
+  const keys = Reflect.ownKeys(value)
+  if (keys.some(key => typeof key !== "string")) return jsonPath(path)
+  if (Array.isArray(value) && (keys.some(key => key !== "length" && !/^(0|[1-9]\d*)$/.test(key)) || keys.length - 1 !== value.length)) return jsonPath(path)
   seen.add(value)
-  for (const [key, descriptor] of Object.entries(descriptors)) {
+  for (const key of keys) {
     if (Array.isArray(value) && key === "length") continue
-    if (!descriptor.enumerable || !("value" in descriptor)) return `${path}.${key}`
-    const invalid = invalidJsonPath(descriptor.value, seen, `${path}.${key}`)
+    const descriptor = Object.getOwnPropertyDescriptor(value, key)
+    path.push(key)
+    if (!descriptor.enumerable || !("value" in descriptor)) return jsonPath(path)
+    const invalid = invalidJsonPath(descriptor.value, seen, safe, path)
     if (invalid) return invalid
+    path.pop()
   }
   seen.delete(value)
+  safe.add(value)
   return undefined
 }
 
+const jsonPath = path => `$${path.map(key => `.${key}`).join("")}`
+
 const isRecord = value => value !== null && typeof value === "object" && !Array.isArray(value)
 const nonempty = value => typeof value === "string" && value.length > 0
 const rowTemplate = value => nonempty(value) && value.includes("$k")

package/framework/compiler/runtime-codegen.mjs

@@ -7,8 +7,8 @@ export function generateCoreRuntime(source, capabilityIR) {
   if (!effects.itemDependencies && capabilityIR.runtime.shared) runtime = replaceRequired(runtime, /\/\* list-item-hooks \*\/[\s\S]*?\/\* list-item-hooks-end \*\/\n/, "", "list item hooks", "shared-runtime.js")
   if (effects.navigable) runtime = replaceRequired(runtime, "export function registerCommitter(commit) {\n  committers.push(commit)\n}", "export function registerCommitter(commit) {\n  committers.push(commit)\n  return () => {\n    const index = committers.indexOf(commit)\n    if (index !== -1) committers.splice(index, 1)\n  }\n}", "navigable committer", "shared-runtime.js")
   if (effects.navigableOwners) runtime = replaceSequenceRequired(runtime, [
-    ["export function registerMountHook(mount) {\n  mountHooks.push(mount)\n}", "export function registerMountHook(mount) {\n  mountHooks.push(mount)\n  return () => {\n    const index = mountHooks.indexOf(mount)\n    if (index !== -1) mountHooks.splice(index, 1)\n  }\n}", "navigable mount hook"],
-    ["export function registerUnmountHook(unmount) {\n  unmountHooks.push(unmount)\n}", "export function registerUnmountHook(unmount) {\n  unmountHooks.push(unmount)\n  return () => {\n    const index = unmountHooks.indexOf(unmount)\n    if (index !== -1) unmountHooks.splice(index, 1)\n  }\n}", "navigable unmount hook"]
+    ["export function registerMountHook(mount, capability) {\n  mountHooks.push({ mount, capability })\n}", "export function registerMountHook(mount, capability) {\n  const entry = { mount, capability }\n  mountHooks.push(entry)\n  return () => {\n    const index = mountHooks.indexOf(entry)\n    if (index !== -1) mountHooks.splice(index, 1)\n  }\n}", "navigable mount hook"],
+    ["export function registerUnmountHook(unmount, capability) {\n  unmountHooks.push({ unmount, capability })\n}", "export function registerUnmountHook(unmount, capability) {\n  const entry = { unmount, capability }\n  unmountHooks.push(entry)\n  return () => {\n    const index = unmountHooks.indexOf(entry)\n    if (index !== -1) unmountHooks.splice(index, 1)\n  }\n}", "navigable unmount hook"]
   ], "shared-runtime.js")
   return runtime
 }