/** The captured DOM ABI both `velar/web` and an emitted program's own JSX reach the document through. */
export declare const WEB_DOM_HOST_RUNTIME = "const __velarDomNativeObject = globalThis.Object;\nconst __velarDomNativeArray = globalThis.Array;\nconst __velarDomNativeSet = globalThis.Set;\nconst __velarDomNativeNumber = globalThis.Number;\nconst __velarDomNativeString = globalThis.String;\nconst __velarDomNativeSymbol = globalThis.Symbol;\nconst __velarDomReflectApply = Object.getOwnPropertyDescriptor(Reflect, \"apply\")?.value;\nconst __velarDomGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor(Object, \"getOwnPropertyDescriptor\")?.value;\nconst __velarDomGetOwnPropertyNames = Object.getOwnPropertyDescriptor(Object, \"getOwnPropertyNames\")?.value;\nconst __velarDomGetOwnPropertySymbols = Object.getOwnPropertyDescriptor(Object, \"getOwnPropertySymbols\")?.value;\nconst __velarDomGetPrototypeOf = Object.getOwnPropertyDescriptor(Object, \"getPrototypeOf\")?.value;\nconst __velarDomDefineProperty = Object.getOwnPropertyDescriptor(Object, \"defineProperty\")?.value;\nconst __velarDomArrayIsArray = Object.getOwnPropertyDescriptor(Array, \"isArray\")?.value;\nconst __velarDomNumberIsFinite = Object.getOwnPropertyDescriptor(Number, \"isFinite\")?.value;\nconst __velarDomNumberIsInteger = Object.getOwnPropertyDescriptor(Number, \"isInteger\")?.value;\nconst __velarDomSymbolHasInstance = typeof __velarDomNativeSymbol === \"function\" ? __velarDomNativeSymbol.hasInstance : null;\nconst __velarDomFunctionHasInstance = __velarDomSymbolHasInstance == null\n  ? null\n  : Object.getOwnPropertyDescriptor(Function.prototype, __velarDomSymbolHasInstance)?.value;\nconst __velarDomSetPrototype = typeof __velarDomNativeSet === \"function\"\n  ? Object.getOwnPropertyDescriptor(__velarDomNativeSet, \"prototype\")?.value\n  : null;\nconst __velarDomSetHas = __velarDomSetPrototype && Object.getOwnPropertyDescriptor(__velarDomSetPrototype, \"has\")?.value;\nconst __velarDomSetAdd = __velarDomSetPrototype && Object.getOwnPropertyDescriptor(__velarDomSetPrototype, \"add\")?.value;\nconst __velarDomSetDelete = __velarDomSetPrototype && Object.getOwnPropertyDescriptor(__velarDomSetPrototype, \"delete\")?.value;\nconst __velarDomDocument = globalThis.document ?? null;\nconst __velarDomNativeNode = typeof globalThis.Node === \"function\" ? globalThis.Node : null;\nconst __velarDomNativeElement = typeof globalThis.Element === \"function\" ? globalThis.Element : null;\nconst __velarDomNativeDocument = typeof globalThis.Document === \"function\" ? globalThis.Document : null;\nconst __velarDomNativeFragment = typeof globalThis.DocumentFragment === \"function\" ? globalThis.DocumentFragment : null;\nconst __velarDomNativeCharacterData = typeof globalThis.CharacterData === \"function\" ? globalThis.CharacterData : null;\nconst __velarDomNativeDocumentType = typeof globalThis.DocumentType === \"function\" ? globalThis.DocumentType : null;\nconst __velarDomNativeNodeList = typeof globalThis.NodeList === \"function\" ? globalThis.NodeList : null;\nconst __velarDomNativeEventTarget = typeof globalThis.EventTarget === \"function\" ? globalThis.EventTarget : null;\nconst __velarDomNativeHtmlElement = typeof globalThis.HTMLElement === \"function\" ? globalThis.HTMLElement : null;\nconst __velarDomNativeSvgElement = typeof globalThis.SVGElement === \"function\" ? globalThis.SVGElement : null;\nconst __velarDomNativeStyleDeclaration = typeof globalThis.CSSStyleDeclaration === \"function\" ? globalThis.CSSStyleDeclaration : null;\nconst __velarDomNativeTokenList = typeof globalThis.DOMTokenList === \"function\" ? globalThis.DOMTokenList : null;\nconst __velarDomNativeInputElement = typeof globalThis.HTMLInputElement === \"function\" ? globalThis.HTMLInputElement : null;\nconst __velarDomNativeTextAreaElement = typeof globalThis.HTMLTextAreaElement === \"function\" ? globalThis.HTMLTextAreaElement : null;\nconst __velarDomNativeSelectElement = typeof globalThis.HTMLSelectElement === \"function\" ? globalThis.HTMLSelectElement : null;\nfunction __velarDomApply(operation, receiver, arguments_, label) {\n  if (typeof operation !== \"function\" || typeof __velarDomReflectApply !== \"function\") {\n    throw new TypeError(\"The browser \" + label + \" API is unavailable\");\n  }\n  return __velarDomReflectApply(operation, receiver, arguments_);\n}\nfunction __velarDomOwnDescriptor(value, name) {\n  if ((typeof value !== \"object\" && typeof value !== \"function\") || value === null\n    || typeof __velarDomGetOwnPropertyDescriptor !== \"function\" || typeof __velarDomReflectApply !== \"function\") return null;\n  return __velarDomReflectApply(__velarDomGetOwnPropertyDescriptor, __velarDomNativeObject, [value, name]) ?? null;\n}\nfunction __velarDomMember(value, name, kind = \"value\") {\n  if ((typeof value !== \"object\" && typeof value !== \"function\") || value === null) return null;\n  let current = value;\n  for (let depth = 0; current && depth < 32; depth += 1) {\n    const descriptor = __velarDomOwnDescriptor(current, name);\n    if (descriptor) {\n      const member = kind === \"get\" ? descriptor.get : kind === \"set\" ? descriptor.set : \"value\" in descriptor ? descriptor.value : null;\n      return typeof member === \"function\" ? member : null;\n    }\n    if (typeof __velarDomGetPrototypeOf !== \"function\" || typeof __velarDomReflectApply !== \"function\") return null;\n    current = __velarDomReflectApply(__velarDomGetPrototypeOf, __velarDomNativeObject, [current]);\n  }\n  return null;\n}\nfunction __velarDomPrototype(constructor) {\n  return typeof constructor === \"function\" ? __velarDomOwnDescriptor(constructor, \"prototype\")?.value ?? null : null;\n}\nfunction __velarDomPrototypeMember(constructor, name, kind = \"value\") {\n  return __velarDomMember(__velarDomPrototype(constructor), name, kind);\n}\nfunction __velarDomInstance(value, constructor) {\n  if (typeof constructor !== \"function\" || typeof __velarDomFunctionHasInstance !== \"function\") return false;\n  try { return __velarDomApply(__velarDomFunctionHasInstance, constructor, [value], \"Node identity\"); }\n  catch { return false; }\n}\nconst __velarDomDocumentCreateElement = __velarDomMember(__velarDomDocument, \"createElement\");\nconst __velarDomDocumentCreateElementNS = __velarDomMember(__velarDomDocument, \"createElementNS\");\nconst __velarDomDocumentCreateTextNode = __velarDomMember(__velarDomDocument, \"createTextNode\");\nconst __velarDomDocumentCreateComment = __velarDomMember(__velarDomDocument, \"createComment\");\nconst __velarDomDocumentCreateFragment = __velarDomMember(__velarDomDocument, \"createDocumentFragment\");\nconst __velarDomDocumentQuerySelector = __velarDomMember(__velarDomDocument, \"querySelector\");\nconst __velarDomNodeNodeType = __velarDomPrototypeMember(__velarDomNativeNode, \"nodeType\", \"get\");\nconst __velarDomElementNamespaceURI = __velarDomPrototypeMember(__velarDomNativeElement, \"namespaceURI\", \"get\");\nconst __velarDomNodeChildNodes = __velarDomPrototypeMember(__velarDomNativeNode, \"childNodes\", \"get\");\nconst __velarDomNodeInsertBefore = __velarDomPrototypeMember(__velarDomNativeNode, \"insertBefore\");\nconst __velarDomNodeReplaceChildren = __velarDomPrototypeMember(__velarDomNativeNode, \"replaceChildren\");\nconst __velarDomNodeAppend = __velarDomPrototypeMember(__velarDomNativeNode, \"append\");\nconst __velarDomNodeTextContentSet = __velarDomPrototypeMember(__velarDomNativeNode, \"textContent\", \"set\");\nconst __velarDomCharacterDataDataSet = __velarDomPrototypeMember(__velarDomNativeCharacterData, \"data\", \"set\");\nconst __velarDomElementAppend = __velarDomPrototypeMember(__velarDomNativeElement, \"append\");\nconst __velarDomElementReplaceChildren = __velarDomPrototypeMember(__velarDomNativeElement, \"replaceChildren\");\nconst __velarDomDocumentAppend = __velarDomPrototypeMember(__velarDomNativeDocument, \"append\");\nconst __velarDomDocumentReplaceChildren = __velarDomPrototypeMember(__velarDomNativeDocument, \"replaceChildren\");\nconst __velarDomFragmentAppend = __velarDomPrototypeMember(__velarDomNativeFragment, \"append\");\nconst __velarDomFragmentReplaceChildren = __velarDomPrototypeMember(__velarDomNativeFragment, \"replaceChildren\");\nconst __velarDomNodeRemove = __velarDomPrototypeMember(__velarDomNativeNode, \"remove\");\nconst __velarDomElementRemove = __velarDomPrototypeMember(__velarDomNativeElement, \"remove\");\nconst __velarDomCharacterDataRemove = __velarDomPrototypeMember(__velarDomNativeCharacterData, \"remove\");\nconst __velarDomDocumentTypeRemove = __velarDomPrototypeMember(__velarDomNativeDocumentType, \"remove\");\nconst __velarDomNodeBefore = __velarDomPrototypeMember(__velarDomNativeNode, \"before\");\nconst __velarDomElementBefore = __velarDomPrototypeMember(__velarDomNativeElement, \"before\");\nconst __velarDomCharacterDataBefore = __velarDomPrototypeMember(__velarDomNativeCharacterData, \"before\");\nconst __velarDomDocumentTypeBefore = __velarDomPrototypeMember(__velarDomNativeDocumentType, \"before\");\nconst __velarDomNodeSetAttribute = __velarDomPrototypeMember(__velarDomNativeNode, \"setAttribute\");\nconst __velarDomElementSetAttribute = __velarDomPrototypeMember(__velarDomNativeElement, \"setAttribute\");\nconst __velarDomElementSetAttributeNS = __velarDomPrototypeMember(__velarDomNativeElement, \"setAttributeNS\");\nconst __velarDomNodeRemoveAttribute = __velarDomPrototypeMember(__velarDomNativeNode, \"removeAttribute\");\nconst __velarDomElementRemoveAttribute = __velarDomPrototypeMember(__velarDomNativeElement, \"removeAttribute\");\nconst __velarDomElementRemoveAttributeNS = __velarDomPrototypeMember(__velarDomNativeElement, \"removeAttributeNS\");\nconst __velarDomNodeListLength = __velarDomPrototypeMember(__velarDomNativeNodeList, \"length\", \"get\");\nconst __velarDomNodeListItem = __velarDomPrototypeMember(__velarDomNativeNodeList, \"item\");\nconst __velarDomNodeNextSibling = __velarDomPrototypeMember(__velarDomNativeNode, \"nextSibling\", \"get\");\nconst __velarDomNodeAddListener = __velarDomPrototypeMember(__velarDomNativeNode, \"addEventListener\");\nconst __velarDomNodeRemoveListener = __velarDomPrototypeMember(__velarDomNativeNode, \"removeEventListener\");\nconst __velarDomNodeInnerHtml = __velarDomPrototypeMember(__velarDomNativeNode, \"innerHTML\", \"set\");\nconst __velarDomNodeQuerySelectorAll = __velarDomPrototypeMember(__velarDomNativeNode, \"querySelectorAll\");\nconst __velarDomNodeClassList = __velarDomPrototypeMember(__velarDomNativeNode, \"classList\", \"get\");\nconst __velarDomNodeStyle = __velarDomPrototypeMember(__velarDomNativeNode, \"style\", \"get\");\nconst __velarDomNodeFieldValue = __velarDomPrototypeMember(__velarDomNativeNode, \"value\", \"get\");\nconst __velarDomNodeSetFieldValue = __velarDomPrototypeMember(__velarDomNativeNode, \"value\", \"set\");\nconst __velarDomNodeFieldNumber = __velarDomPrototypeMember(__velarDomNativeNode, \"valueAsNumber\", \"get\");\nconst __velarDomNodeFieldChecked = __velarDomPrototypeMember(__velarDomNativeNode, \"checked\", \"get\");\nconst __velarDomNodeSetFieldChecked = __velarDomPrototypeMember(__velarDomNativeNode, \"checked\", \"set\");\nconst __velarDomEventTargetAdd = __velarDomPrototypeMember(__velarDomNativeEventTarget, \"addEventListener\");\nconst __velarDomEventTargetRemove = __velarDomPrototypeMember(__velarDomNativeEventTarget, \"removeEventListener\");\nconst __velarDomElementInnerHtml = __velarDomPrototypeMember(__velarDomNativeElement, \"innerHTML\", \"set\");\nconst __velarDomElementQuerySelectorAll = __velarDomPrototypeMember(__velarDomNativeElement, \"querySelectorAll\");\nconst __velarDomElementClassList = __velarDomPrototypeMember(__velarDomNativeElement, \"classList\", \"get\");\nconst __velarDomHtmlElementStyle = __velarDomPrototypeMember(__velarDomNativeHtmlElement, \"style\", \"get\");\nconst __velarDomSvgElementStyle = __velarDomPrototypeMember(__velarDomNativeSvgElement, \"style\", \"get\");\nconst __velarDomStyleSetProperty = __velarDomPrototypeMember(__velarDomNativeStyleDeclaration, \"setProperty\");\nconst __velarDomStyleRemoveProperty = __velarDomPrototypeMember(__velarDomNativeStyleDeclaration, \"removeProperty\");\nconst __velarDomStylePropertyValue = __velarDomPrototypeMember(__velarDomNativeStyleDeclaration, \"getPropertyValue\");\nconst __velarDomStylePropertyPriority = __velarDomPrototypeMember(__velarDomNativeStyleDeclaration, \"getPropertyPriority\");\nconst __velarDomTokenListAdd = __velarDomPrototypeMember(__velarDomNativeTokenList, \"add\");\nconst __velarDomTokenListRemove = __velarDomPrototypeMember(__velarDomNativeTokenList, \"remove\");\nconst __velarDomTokenListLength = __velarDomPrototypeMember(__velarDomNativeTokenList, \"length\", \"get\");\nconst __velarDomTokenListItem = __velarDomPrototypeMember(__velarDomNativeTokenList, \"item\");\nconst __velarDomInputValueGet = __velarDomPrototypeMember(__velarDomNativeInputElement, \"value\", \"get\");\nconst __velarDomInputValueSet = __velarDomPrototypeMember(__velarDomNativeInputElement, \"value\", \"set\");\nconst __velarDomInputNumberGet = __velarDomPrototypeMember(__velarDomNativeInputElement, \"valueAsNumber\", \"get\");\nconst __velarDomInputCheckedGet = __velarDomPrototypeMember(__velarDomNativeInputElement, \"checked\", \"get\");\nconst __velarDomInputCheckedSet = __velarDomPrototypeMember(__velarDomNativeInputElement, \"checked\", \"set\");\nconst __velarDomTextAreaValueGet = __velarDomPrototypeMember(__velarDomNativeTextAreaElement, \"value\", \"get\");\nconst __velarDomTextAreaValueSet = __velarDomPrototypeMember(__velarDomNativeTextAreaElement, \"value\", \"set\");\nconst __velarDomSelectValueGet = __velarDomPrototypeMember(__velarDomNativeSelectElement, \"value\", \"get\");\nconst __velarDomSelectValueSet = __velarDomPrototypeMember(__velarDomNativeSelectElement, \"value\", \"set\");\nfunction __velarDomOwnData(value, name) {\n  const descriptor = __velarDomOwnDescriptor(value, name);\n  return descriptor?.enumerable && \"value\" in descriptor ? descriptor.value : undefined;\n}\nfunction __velarDomOwnMethod(value, name) {\n  const method = __velarDomOwnData(value, name);\n  return typeof method === \"function\" ? method : null;\n}\nfunction __velarDomNodeOperation(value, name, candidates, arguments_) {\n  for (let index = 0; index < candidates.length; index += 1) {\n    const candidate = candidates[index];\n    if (__velarDomInstance(value, candidate[0]) && typeof candidate[1] === \"function\") {\n      return __velarDomApply(candidate[1], value, arguments_, \"DOM \" + name);\n    }\n  }\n  const own = __velarDomOwnMethod(value, name);\n  if (own) return __velarDomApply(own, value, arguments_, \"DOM \" + name);\n  throw new TypeError(\"The value does not expose native DOM \" + name);\n}\nfunction __velarDomCreateElement(tag) { return __velarDomApply(__velarDomDocumentCreateElement, __velarDomDocument, [tag], \"document.createElement\"); }\nfunction __velarDomCreateElementNS(namespace, tag) { return __velarDomApply(__velarDomDocumentCreateElementNS, __velarDomDocument, [namespace, tag], \"document.createElementNS\"); }\nfunction __velarDomCreateTextNode(value) { return __velarDomApply(__velarDomDocumentCreateTextNode, __velarDomDocument, [value], \"document.createTextNode\"); }\nfunction __velarDomCreateComment(value) { return __velarDomApply(__velarDomDocumentCreateComment, __velarDomDocument, [value], \"document.createComment\"); }\nfunction __velarDomCreateFragment() { return __velarDomApply(__velarDomDocumentCreateFragment, __velarDomDocument, [], \"document.createDocumentFragment\"); }\nfunction __velarDomQuerySelector(value) { return __velarDomApply(__velarDomDocumentQuerySelector, __velarDomDocument, [value], \"document.querySelector\"); }\nfunction __velarDomAppend(value, ...children) {\n  return __velarDomNodeOperation(value, \"append\", [\n    [__velarDomNativeNode, __velarDomNodeAppend], [__velarDomNativeElement, __velarDomElementAppend],\n    [__velarDomNativeDocument, __velarDomDocumentAppend], [__velarDomNativeFragment, __velarDomFragmentAppend],\n  ], children);\n}\nfunction __velarDomInsertBefore(value, child, before = null) {\n  return __velarDomNodeOperation(value, \"insertBefore\", [[__velarDomNativeNode, __velarDomNodeInsertBefore]], [child, before]);\n}\nfunction __velarDomReplaceChildren(value, ...children) {\n  return __velarDomNodeOperation(value, \"replaceChildren\", [\n    [__velarDomNativeNode, __velarDomNodeReplaceChildren], [__velarDomNativeElement, __velarDomElementReplaceChildren],\n    [__velarDomNativeDocument, __velarDomDocumentReplaceChildren], [__velarDomNativeFragment, __velarDomFragmentReplaceChildren],\n  ], children);\n}\nfunction __velarDomRemove(value) {\n  return __velarDomNodeOperation(value, \"remove\", [\n    [__velarDomNativeNode, __velarDomNodeRemove], [__velarDomNativeElement, __velarDomElementRemove],\n    [__velarDomNativeCharacterData, __velarDomCharacterDataRemove], [__velarDomNativeDocumentType, __velarDomDocumentTypeRemove],\n  ], []);\n}\nfunction __velarDomBefore(value, child) {\n  return __velarDomNodeOperation(value, \"before\", [\n    [__velarDomNativeNode, __velarDomNodeBefore], [__velarDomNativeElement, __velarDomElementBefore],\n    [__velarDomNativeCharacterData, __velarDomCharacterDataBefore], [__velarDomNativeDocumentType, __velarDomDocumentTypeBefore],\n  ], [child]);\n}\nfunction __velarDomSetAttribute(value, name, next) {\n  return __velarDomNodeOperation(value, \"setAttribute\", [\n    [__velarDomNativeNode, __velarDomNodeSetAttribute], [__velarDomNativeElement, __velarDomElementSetAttribute],\n  ], [name, next]);\n}\nfunction __velarDomSetAttributeNS(value, namespace, name, next) {\n  return __velarDomNodeOperation(value, \"setAttributeNS\", [[__velarDomNativeElement, __velarDomElementSetAttributeNS]], [namespace, name, next]);\n}\nfunction __velarDomRemoveAttribute(value, name) {\n  return __velarDomNodeOperation(value, \"removeAttribute\", [\n    [__velarDomNativeNode, __velarDomNodeRemoveAttribute], [__velarDomNativeElement, __velarDomElementRemoveAttribute],\n  ], [name]);\n}\nfunction __velarDomRemoveAttributeNS(value, namespace, name) {\n  return __velarDomNodeOperation(value, \"removeAttributeNS\", [[__velarDomNativeElement, __velarDomElementRemoveAttributeNS]], [namespace, name]);\n}\n// Accessor twin of __velarDomNodeOperation: the framework reads and writes a\n// handful of host properties (style, classList, innerHTML, field value) whose\n// prototypes are as replaceable as the methods above, so they go through the\n// same captured-then-own-data-descriptor path instead of ambient '.' access.\nfunction __velarDomNodeAccessor(value, name, candidates, arguments_, write) {\n  for (let index = 0; index < candidates.length; index += 1) {\n    const candidate = candidates[index];\n    if (__velarDomInstance(value, candidate[0]) && typeof candidate[1] === \"function\") {\n      return __velarDomApply(candidate[1], value, arguments_, \"DOM \" + name);\n    }\n  }\n  const descriptor = __velarDomOwnDescriptor(value, name);\n  if (!write) {\n    if (descriptor && \"value\" in descriptor) return descriptor.value;\n    throw new TypeError(\"The value does not expose native DOM \" + name);\n  }\n  if (typeof __velarDomDefineProperty !== \"function\" || typeof __velarDomReflectApply !== \"function\"\n    || (descriptor && (!(\"value\" in descriptor) || descriptor.writable !== true))) {\n    throw new TypeError(\"The value does not expose native DOM \" + name);\n  }\n  return __velarDomReflectApply(__velarDomDefineProperty, __velarDomNativeObject, [value, name, descriptor\n    ? { ...descriptor, value: arguments_[0] }\n    : { value: arguments_[0], writable: true, enumerable: true, configurable: true }]);\n}\nfunction __velarDomNextSibling(value) {\n  if (__velarDomInstance(value, __velarDomNativeNode) && typeof __velarDomNodeNextSibling === \"function\") {\n    return __velarDomApply(__velarDomNodeNextSibling, value, [], \"Node.nextSibling\");\n  }\n  return null;\n}\nfunction __velarDomAddListener(value, name, listener, options) {\n  return __velarDomNodeOperation(value, \"addEventListener\", [\n    [__velarDomNativeNode, __velarDomNodeAddListener], [__velarDomNativeEventTarget, __velarDomEventTargetAdd],\n  ], [name, listener, options]);\n}\nfunction __velarDomRemoveListener(value, name, listener, options) {\n  return __velarDomNodeOperation(value, \"removeEventListener\", [\n    [__velarDomNativeNode, __velarDomNodeRemoveListener], [__velarDomNativeEventTarget, __velarDomEventTargetRemove],\n  ], [name, listener, options]);\n}\n// The in-place text update. A scalar interpolation owns one text node for its\n// whole life and rewrites its character data rather than replacing the node, so\n// 'data' joins the captured accessor ABI beside 'innerHTML' and 'value': a\n// planted CharacterData.prototype setter must not be able to observe or divert\n// what the framework writes into its own node.\nfunction __velarDomSetData(value, next) {\n  return __velarDomNodeAccessor(value, \"data\", [[__velarDomNativeCharacterData, __velarDomCharacterDataDataSet]], [next], true);\n}\nfunction __velarDomSetHtml(value, next) {\n  return __velarDomNodeAccessor(value, \"innerHTML\", [\n    [__velarDomNativeNode, __velarDomNodeInnerHtml], [__velarDomNativeElement, __velarDomElementInnerHtml],\n  ], [next], true);\n}\nfunction __velarDomQuerySelectorAll(value, selector) {\n  return __velarDomNodeOperation(value, \"querySelectorAll\", [\n    [__velarDomNativeNode, __velarDomNodeQuerySelectorAll], [__velarDomNativeElement, __velarDomElementQuerySelectorAll],\n  ], [selector]);\n}\nfunction __velarDomStyle(value) {\n  return __velarDomNodeAccessor(value, \"style\", [\n    [__velarDomNativeNode, __velarDomNodeStyle], [__velarDomNativeHtmlElement, __velarDomHtmlElementStyle],\n    [__velarDomNativeSvgElement, __velarDomSvgElementStyle],\n  ], [], false);\n}\nfunction __velarDomStyleValue(value, property) {\n  return __velarDomNodeOperation(__velarDomStyle(value), \"getPropertyValue\", [[__velarDomNativeStyleDeclaration, __velarDomStylePropertyValue]], [property]);\n}\nfunction __velarDomStylePriority(value, property) {\n  return __velarDomNodeOperation(__velarDomStyle(value), \"getPropertyPriority\", [[__velarDomNativeStyleDeclaration, __velarDomStylePropertyPriority]], [property]);\n}\nfunction __velarDomStyleWrite(value, property, next, priority = \"\") {\n  return __velarDomNodeOperation(__velarDomStyle(value), \"setProperty\", [[__velarDomNativeStyleDeclaration, __velarDomStyleSetProperty]], [property, next, priority]);\n}\nfunction __velarDomStyleClear(value, property) {\n  return __velarDomNodeOperation(__velarDomStyle(value), \"removeProperty\", [[__velarDomNativeStyleDeclaration, __velarDomStyleRemoveProperty]], [property]);\n}\nfunction __velarDomClassList(value) {\n  return __velarDomNodeAccessor(value, \"classList\", [\n    [__velarDomNativeNode, __velarDomNodeClassList], [__velarDomNativeElement, __velarDomElementClassList],\n  ], [], false);\n}\nfunction __velarDomClassInsert(value, name) {\n  return __velarDomNodeOperation(__velarDomClassList(value), \"add\", [[__velarDomNativeTokenList, __velarDomTokenListAdd]], [name]);\n}\nfunction __velarDomClassRemove(value, name) {\n  return __velarDomNodeOperation(__velarDomClassList(value), \"remove\", [[__velarDomNativeTokenList, __velarDomTokenListRemove]], [name]);\n}\nfunction __velarDomClassNames(value) {\n  const list = __velarDomClassList(value);\n  const length = __velarDomInstance(list, __velarDomNativeTokenList) && typeof __velarDomTokenListLength === \"function\"\n    ? __velarDomApply(__velarDomTokenListLength, list, [], \"DOMTokenList.length\")\n    : __velarDomOwnData(list, \"length\");\n  // A data-only seam that exposes no bounded token list simply owns no base\n  // classes; only a real token list can contribute names the framework must\n  // preserve while it manages the rest.\n  if (!__velarDomIsInteger(length) || length < 0 || length > 1000000) return new __velarDomNativeArray(0);\n  const output = new __velarDomNativeArray(length);\n  for (let index = 0; index < length; index += 1) {\n    output[index] = __velarDomNodeOperation(list, \"item\", [[__velarDomNativeTokenList, __velarDomTokenListItem]], [index]);\n  }\n  return output;\n}\nfunction __velarDomFieldValue(value) {\n  return __velarDomNodeAccessor(value, \"value\", [\n    [__velarDomNativeNode, __velarDomNodeFieldValue], [__velarDomNativeInputElement, __velarDomInputValueGet],\n    [__velarDomNativeTextAreaElement, __velarDomTextAreaValueGet], [__velarDomNativeSelectElement, __velarDomSelectValueGet],\n  ], [], false);\n}\nfunction __velarDomSetFieldValue(value, next) {\n  return __velarDomNodeAccessor(value, \"value\", [\n    [__velarDomNativeNode, __velarDomNodeSetFieldValue], [__velarDomNativeInputElement, __velarDomInputValueSet],\n    [__velarDomNativeTextAreaElement, __velarDomTextAreaValueSet], [__velarDomNativeSelectElement, __velarDomSelectValueSet],\n  ], [next], true);\n}\nfunction __velarDomFieldNumber(value) {\n  return __velarDomNodeAccessor(value, \"valueAsNumber\", [\n    [__velarDomNativeNode, __velarDomNodeFieldNumber], [__velarDomNativeInputElement, __velarDomInputNumberGet],\n  ], [], false);\n}\nfunction __velarDomFieldChecked(value) {\n  return __velarDomNodeAccessor(value, \"checked\", [\n    [__velarDomNativeNode, __velarDomNodeFieldChecked], [__velarDomNativeInputElement, __velarDomInputCheckedGet],\n  ], [], false);\n}\nfunction __velarDomSetFieldChecked(value, next) {\n  return __velarDomNodeAccessor(value, \"checked\", [\n    [__velarDomNativeNode, __velarDomNodeSetFieldChecked], [__velarDomNativeInputElement, __velarDomInputCheckedSet],\n  ], [next], true);\n}\nfunction __velarDomNodeType(value) {\n  if (__velarDomInstance(value, __velarDomNativeNode) && typeof __velarDomNodeNodeType === \"function\") {\n    return __velarDomApply(__velarDomNodeNodeType, value, [], \"Node.nodeType\");\n  }\n  const nodeType = __velarDomOwnData(value, \"nodeType\");\n  return typeof nodeType === \"number\" ? nodeType : null;\n}\n// WB-U1: which document a node belongs to, read the way every other host field\n// here is read. The root fatal state needs it because the position it replaces\n// is a mount target the program named at runtime -- unlike a region, whose\n// namespace the lowering already knows -- and an HTML '<section>' inside\n// '<svg>' is content a browser lays out none of.\nfunction __velarDomNamespace(value) {\n  if (__velarDomInstance(value, __velarDomNativeElement) && typeof __velarDomElementNamespaceURI === \"function\") {\n    const namespace = __velarDomApply(__velarDomElementNamespaceURI, value, [], \"Element.namespaceURI\");\n    return typeof namespace === \"string\" ? namespace : null;\n  }\n  const namespace = __velarDomOwnData(value, \"namespaceURI\");\n  return typeof namespace === \"string\" ? namespace : null;\n}\nfunction __velarDomSetText(value, next) {\n  if (__velarDomInstance(value, __velarDomNativeNode) && typeof __velarDomNodeTextContentSet === \"function\") {\n    return __velarDomApply(__velarDomNodeTextContentSet, value, [next], \"Node.textContent\");\n  }\n  const descriptor = __velarDomOwnDescriptor(value, \"textContent\");\n  if (!descriptor?.enumerable || !(\"value\" in descriptor) || descriptor.writable !== true\n    || typeof __velarDomDefineProperty !== \"function\" || typeof __velarDomReflectApply !== \"function\") {\n    throw new TypeError(\"The value does not expose native DOM textContent\");\n  }\n  return __velarDomReflectApply(__velarDomDefineProperty, __velarDomNativeObject, [value, \"textContent\", { ...descriptor, value: next }]);\n}\nfunction __velarDomIsNode(value) {\n  return __velarDomInstance(value, __velarDomNativeNode) || __velarDomNodeType(value) !== null;\n}\nfunction __velarDomCollectionSnapshot(value, name) {\n  let length = null;\n  let read = null;\n  if (__velarDomInstance(value, __velarDomNativeNodeList) && typeof __velarDomNodeListLength === \"function\" && typeof __velarDomNodeListItem === \"function\") {\n    length = __velarDomApply(__velarDomNodeListLength, value, [], name + \".length\");\n    read = (index) => __velarDomApply(__velarDomNodeListItem, value, [index], name + \".item\");\n  } else if (__velarDomIsArray(value)) {\n    length = __velarDomOwnDescriptor(value, \"length\")?.value;\n    read = (index) => __velarDomOwnDescriptor(value, index)?.value;\n  }\n  if (!__velarDomIsInteger(length) || length < 0 || length > 1000000 || read === null) throw new TypeError(name + \" is not a bounded native collection\");\n  const output = new __velarDomNativeArray(length);\n  for (let index = 0; index < length; index += 1) output[index] = read(index);\n  return output;\n}\nfunction __velarDomChildNodes(value) {\n  let children;\n  if (__velarDomInstance(value, __velarDomNativeNode) && typeof __velarDomNodeChildNodes === \"function\") {\n    children = __velarDomApply(__velarDomNodeChildNodes, value, [], \"Node.childNodes\");\n  } else children = __velarDomOwnData(value, \"childNodes\");\n  return __velarDomCollectionSnapshot(children, \"Node.childNodes\");\n}\nfunction __velarDomIsArray(value) {\n  return typeof __velarDomArrayIsArray === \"function\" && typeof __velarDomReflectApply === \"function\"\n    && __velarDomReflectApply(__velarDomArrayIsArray, __velarDomNativeArray, [value]);\n}\nfunction __velarDomIsFinite(value) {\n  return typeof __velarDomNumberIsFinite === \"function\" && typeof __velarDomReflectApply === \"function\"\n    && __velarDomReflectApply(__velarDomNumberIsFinite, __velarDomNativeNumber, [value]);\n}\nfunction __velarDomIsInteger(value) {\n  return typeof __velarDomNumberIsInteger === \"function\" && typeof __velarDomReflectApply === \"function\"\n    && __velarDomReflectApply(__velarDomNumberIsInteger, __velarDomNativeNumber, [value]);\n}\nfunction __velarDomString(value) { return __velarDomApply(__velarDomNativeString, undefined, [value], \"String\"); }\nfunction __velarDomListSnapshot(value, name) {\n  if (!__velarDomIsArray(value)) throw new TypeError(name + \" requires a List\");\n  const lengthDescriptor = __velarDomOwnDescriptor(value, \"length\");\n  if (!lengthDescriptor || lengthDescriptor.writable !== true || lengthDescriptor.enumerable\n    || lengthDescriptor.configurable || !(\"value\" in lengthDescriptor)) {\n    throw new TypeError(name + \" requires an ordinary mutable List length\");\n  }\n  const length = lengthDescriptor.value;\n  if (!__velarDomIsInteger(length) || length < 0 || length > 1000000) throw new RangeError(name + \" cannot exceed 1000000 items\");\n  const names = __velarDomApply(__velarDomGetOwnPropertyNames, __velarDomNativeObject, [value]);\n  const symbols = __velarDomApply(__velarDomGetOwnPropertySymbols, __velarDomNativeObject, [value]);\n  if (symbols.length > 0 || names.length !== length + 1) throw new TypeError(name + \" requires a dense List without extra fields\");\n  const output = new __velarDomNativeArray(length);\n  for (let index = 0; index < length; index += 1) {\n    const descriptor = __velarDomOwnDescriptor(value, index);\n    if (!descriptor?.enumerable || !descriptor.configurable || !descriptor.writable || !(\"value\" in descriptor)) {\n      throw new TypeError(name + \" requires ordinary mutable List elements\");\n    }\n    output[index] = descriptor.value;\n  }\n  return output;\n}\nfunction __velarDomCreateSet() {\n  if (typeof __velarDomNativeSet !== \"function\") throw new TypeError(\"The browser Set API is unavailable\");\n  return new __velarDomNativeSet();\n}\nfunction __velarDomSetContains(value, item) { return __velarDomApply(__velarDomSetHas, value, [item], \"Set.has\"); }\nfunction __velarDomSetInsert(value, item) { return __velarDomApply(__velarDomSetAdd, value, [item], \"Set.add\"); }\nfunction __velarDomSetRemove(value, item) { return __velarDomApply(__velarDomSetDelete, value, [item], \"Set.delete\"); }\n";
/** The captured Object/Array/Set/Map ABI the dependency graph is built out of. */
export declare const WEB_REACTIVITY_HOST_RUNTIME = "const __velarGraphNativeObject = globalThis.Object;\nconst __velarGraphNativeArray = globalThis.Array;\nconst __velarGraphNativeSet = globalThis.Set;\nconst __velarGraphNativeMap = globalThis.Map;\nconst __velarGraphNativeWeakSet = globalThis.WeakSet;\nconst __velarGraphNativeWeakMap = globalThis.WeakMap;\nconst __velarGraphNativeProxy = globalThis.Proxy;\nconst __velarGraphReflectApply = Object.getOwnPropertyDescriptor(Reflect, \"apply\")?.value;\nconst __velarGraphArrayIsArray = Object.getOwnPropertyDescriptor(Array, \"isArray\")?.value;\nconst __velarGraphArrayPrototype = Object.getOwnPropertyDescriptor(__velarGraphNativeArray, \"prototype\")?.value;\nconst __velarGraphArraySort = __velarGraphArrayPrototype && Object.getOwnPropertyDescriptor(__velarGraphArrayPrototype, \"sort\")?.value;\nconst __velarGraphObjectIs = Object.getOwnPropertyDescriptor(Object, \"is\")?.value;\nconst __velarGraphObjectFreeze = Object.getOwnPropertyDescriptor(Object, \"freeze\")?.value;\nconst __velarGraphObjectDefineProperty = Object.getOwnPropertyDescriptor(Object, \"defineProperty\")?.value;\nconst __velarGraphObjectIsExtensible = Object.getOwnPropertyDescriptor(Object, \"isExtensible\")?.value;\nconst __velarGraphObjectGetPrototypeOf = Object.getOwnPropertyDescriptor(Object, \"getPrototypeOf\")?.value;\nconst __velarGraphObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor(Object, \"getOwnPropertyDescriptor\")?.value;\nconst __velarGraphObjectGetOwnPropertyNames = Object.getOwnPropertyDescriptor(Object, \"getOwnPropertyNames\")?.value;\nconst __velarGraphObjectCreate = Object.getOwnPropertyDescriptor(Object, \"create\")?.value;\nconst __velarGraphSetPrototype = Object.getOwnPropertyDescriptor(__velarGraphNativeSet, \"prototype\")?.value;\nconst __velarGraphSetHas = __velarGraphSetPrototype && Object.getOwnPropertyDescriptor(__velarGraphSetPrototype, \"has\")?.value;\nconst __velarGraphSetAdd = __velarGraphSetPrototype && Object.getOwnPropertyDescriptor(__velarGraphSetPrototype, \"add\")?.value;\nconst __velarGraphSetDelete = __velarGraphSetPrototype && Object.getOwnPropertyDescriptor(__velarGraphSetPrototype, \"delete\")?.value;\nconst __velarGraphSetClear = __velarGraphSetPrototype && Object.getOwnPropertyDescriptor(__velarGraphSetPrototype, \"clear\")?.value;\nconst __velarGraphSetValues = __velarGraphSetPrototype && Object.getOwnPropertyDescriptor(__velarGraphSetPrototype, \"values\")?.value;\nconst __velarGraphSetSize = __velarGraphSetPrototype && Object.getOwnPropertyDescriptor(__velarGraphSetPrototype, \"size\")?.get;\nconst __velarGraphMapPrototype = Object.getOwnPropertyDescriptor(__velarGraphNativeMap, \"prototype\")?.value;\nconst __velarGraphMapHas = __velarGraphMapPrototype && Object.getOwnPropertyDescriptor(__velarGraphMapPrototype, \"has\")?.value;\nconst __velarGraphMapGet = __velarGraphMapPrototype && Object.getOwnPropertyDescriptor(__velarGraphMapPrototype, \"get\")?.value;\nconst __velarGraphMapSet = __velarGraphMapPrototype && Object.getOwnPropertyDescriptor(__velarGraphMapPrototype, \"set\")?.value;\nconst __velarGraphMapDelete = __velarGraphMapPrototype && Object.getOwnPropertyDescriptor(__velarGraphMapPrototype, \"delete\")?.value;\nconst __velarGraphMapClear = __velarGraphMapPrototype && Object.getOwnPropertyDescriptor(__velarGraphMapPrototype, \"clear\")?.value;\nconst __velarGraphMapValues = __velarGraphMapPrototype && Object.getOwnPropertyDescriptor(__velarGraphMapPrototype, \"values\")?.value;\nconst __velarGraphMapKeys = __velarGraphMapPrototype && Object.getOwnPropertyDescriptor(__velarGraphMapPrototype, \"keys\")?.value;\nconst __velarGraphMapSize = __velarGraphMapPrototype && Object.getOwnPropertyDescriptor(__velarGraphMapPrototype, \"size\")?.get;\nconst __velarGraphWeakSetPrototype = Object.getOwnPropertyDescriptor(__velarGraphNativeWeakSet, \"prototype\")?.value;\nconst __velarGraphWeakSetHas = __velarGraphWeakSetPrototype && Object.getOwnPropertyDescriptor(__velarGraphWeakSetPrototype, \"has\")?.value;\nconst __velarGraphWeakSetAdd = __velarGraphWeakSetPrototype && Object.getOwnPropertyDescriptor(__velarGraphWeakSetPrototype, \"add\")?.value;\nconst __velarGraphWeakSetDelete = __velarGraphWeakSetPrototype && Object.getOwnPropertyDescriptor(__velarGraphWeakSetPrototype, \"delete\")?.value;\nconst __velarGraphWeakMapPrototype = Object.getOwnPropertyDescriptor(__velarGraphNativeWeakMap, \"prototype\")?.value;\nconst __velarGraphWeakMapHas = __velarGraphWeakMapPrototype && Object.getOwnPropertyDescriptor(__velarGraphWeakMapPrototype, \"has\")?.value;\nconst __velarGraphWeakMapGet = __velarGraphWeakMapPrototype && Object.getOwnPropertyDescriptor(__velarGraphWeakMapPrototype, \"get\")?.value;\nconst __velarGraphWeakMapSet = __velarGraphWeakMapPrototype && Object.getOwnPropertyDescriptor(__velarGraphWeakMapPrototype, \"set\")?.value;\nconst __velarGraphWeakMapDelete = __velarGraphWeakMapPrototype && Object.getOwnPropertyDescriptor(__velarGraphWeakMapPrototype, \"delete\")?.value;\nconst __velarGraphReflectGet = Object.getOwnPropertyDescriptor(Reflect, \"get\")?.value;\nconst __velarGraphReflectSet = Object.getOwnPropertyDescriptor(Reflect, \"set\")?.value;\nconst __velarGraphReflectHas = Object.getOwnPropertyDescriptor(Reflect, \"has\")?.value;\nconst __velarGraphReflectDeleteProperty = Object.getOwnPropertyDescriptor(Reflect, \"deleteProperty\")?.value;\nfunction __velarGraphApply(operation, receiver, arguments_, label) {\n  if (typeof operation !== \"function\" || typeof __velarGraphReflectApply !== \"function\") {\n    throw new TypeError(\"The JavaScript \" + label + \" API is unavailable\");\n  }\n  return __velarGraphReflectApply(operation, receiver, arguments_);\n}\nfunction __velarGraphCreateSet(values) {\n  const output = new __velarGraphNativeSet();\n  if (values !== undefined) for (const value of values) __velarGraphSetInsert(output, value);\n  return output;\n}\nfunction __velarGraphCreateMap(values) {\n  const output = new __velarGraphNativeMap();\n  if (values !== undefined) for (const entry of values) __velarGraphMapWrite(output, entry[0], entry[1]);\n  return output;\n}\nfunction __velarGraphCreateWeakSet() { return new __velarGraphNativeWeakSet(); }\nfunction __velarGraphCreateWeakMap() { return new __velarGraphNativeWeakMap(); }\nfunction __velarGraphSetContains(value, item) { return __velarGraphApply(__velarGraphSetHas, value, [item], \"Set.has\"); }\nfunction __velarGraphSetInsert(value, item) { return __velarGraphApply(__velarGraphSetAdd, value, [item], \"Set.add\"); }\nfunction __velarGraphSetRemove(value, item) { return __velarGraphApply(__velarGraphSetDelete, value, [item], \"Set.delete\"); }\nfunction __velarGraphSetEmpty(value) { return __velarGraphApply(__velarGraphSetClear, value, [], \"Set.clear\"); }\nfunction __velarGraphSetItems(value) { return __velarGraphApply(__velarGraphSetValues, value, [], \"Set.values\"); }\nfunction __velarGraphSetCount(value) { return __velarGraphApply(__velarGraphSetSize, value, [], \"Set.size\"); }\nfunction __velarGraphMapContains(value, key) { return __velarGraphApply(__velarGraphMapHas, value, [key], \"Map.has\"); }\nfunction __velarGraphMapRead(value, key) { return __velarGraphApply(__velarGraphMapGet, value, [key], \"Map.get\"); }\nfunction __velarGraphMapWrite(value, key, item) { return __velarGraphApply(__velarGraphMapSet, value, [key, item], \"Map.set\"); }\nfunction __velarGraphMapRemove(value, key) { return __velarGraphApply(__velarGraphMapDelete, value, [key], \"Map.delete\"); }\nfunction __velarGraphMapItems(value) { return __velarGraphApply(__velarGraphMapValues, value, [], \"Map.values\"); }\nfunction __velarGraphMapEmpty(value) { return __velarGraphApply(__velarGraphMapClear, value, [], \"Map.clear\"); }\nfunction __velarGraphMapKeyItems(value) { return __velarGraphApply(__velarGraphMapKeys, value, [], \"Map.keys\"); }\nfunction __velarGraphMapCount(value) { return __velarGraphApply(__velarGraphMapSize, value, [], \"Map.size\"); }\nfunction __velarGraphWeakSetContains(value, item) { return __velarGraphApply(__velarGraphWeakSetHas, value, [item], \"WeakSet.has\"); }\nfunction __velarGraphWeakSetInsert(value, item) { return __velarGraphApply(__velarGraphWeakSetAdd, value, [item], \"WeakSet.add\"); }\nfunction __velarGraphWeakSetRemove(value, item) { return __velarGraphApply(__velarGraphWeakSetDelete, value, [item], \"WeakSet.delete\"); }\nfunction __velarGraphWeakMapContains(value, key) { return __velarGraphApply(__velarGraphWeakMapHas, value, [key], \"WeakMap.has\"); }\nfunction __velarGraphWeakMapRead(value, key) { return __velarGraphApply(__velarGraphWeakMapGet, value, [key], \"WeakMap.get\"); }\nfunction __velarGraphWeakMapWrite(value, key, item) { return __velarGraphApply(__velarGraphWeakMapSet, value, [key, item], \"WeakMap.set\"); }\nfunction __velarGraphWeakMapRemove(value, key) { return __velarGraphApply(__velarGraphWeakMapDelete, value, [key], \"WeakMap.delete\"); }\nfunction __velarGraphIsList(value) { return __velarGraphApply(__velarGraphArrayIsArray, __velarGraphNativeArray, [value], \"Array.isArray\"); }\n// D114 F2: a plain record, as against a List, a Map, a Set or a class instance -- what a proxy is built over, what a report option must be, and which word a nested write is described with.\nfunction __velarGraphIsRecord(value) { const prototype = __velarGraphPrototype(value); return prototype === null || prototype === __velarGraphNativeObject.prototype; }\nfunction __velarGraphOrder(value, compare) { return __velarGraphApply(__velarGraphArraySort, value, [compare], \"Array.sort\"); }\nfunction __velarGraphSame(left, right) { return __velarGraphApply(__velarGraphObjectIs, __velarGraphNativeObject, [left, right], \"Object.is\"); }\nfunction __velarGraphFreeze(value) { return __velarGraphApply(__velarGraphObjectFreeze, __velarGraphNativeObject, [value], \"Object.freeze\"); }\nfunction __velarGraphDefine(value, key, descriptor) { return __velarGraphApply(__velarGraphObjectDefineProperty, __velarGraphNativeObject, [value, key, descriptor], \"Object.defineProperty\"); }\nfunction __velarGraphIsExtensible(value) { return __velarGraphApply(__velarGraphObjectIsExtensible, __velarGraphNativeObject, [value], \"Object.isExtensible\"); }\nfunction __velarGraphPrototype(value) { return __velarGraphApply(__velarGraphObjectGetPrototypeOf, __velarGraphNativeObject, [value], \"Object.getPrototypeOf\"); }\nfunction __velarGraphOwnDescriptor(value, key) { return __velarGraphApply(__velarGraphObjectGetOwnPropertyDescriptor, __velarGraphNativeObject, [value, key], \"Object.getOwnPropertyDescriptor\"); }\nfunction __velarGraphOwnNames(value) { return __velarGraphApply(__velarGraphObjectGetOwnPropertyNames, __velarGraphNativeObject, [value], \"Object.getOwnPropertyNames\"); }\nfunction __velarGraphCreateRecord() { return __velarGraphApply(__velarGraphObjectCreate, __velarGraphNativeObject, [null], \"Object.create\"); }\nfunction __velarGraphGet(value, key, receiver) { return __velarGraphApply(__velarGraphReflectGet, null, [value, key, receiver], \"Reflect.get\"); }\nfunction __velarGraphSet(value, key, item, receiver) { return __velarGraphApply(__velarGraphReflectSet, null, [value, key, item, receiver], \"Reflect.set\"); }\nfunction __velarGraphHas(value, key) { return __velarGraphApply(__velarGraphReflectHas, null, [value, key], \"Reflect.has\"); }\nfunction __velarGraphDelete(value, key) { return __velarGraphApply(__velarGraphReflectDeleteProperty, null, [value, key], \"Reflect.deleteProperty\"); }\n";
export declare const WEB_ERROR_HOST_RUNTIME_BODY = "const __velarWebErrorNativeObject = globalThis.Object;\nconst __velarWebErrorNativeNumber = globalThis.Number;\nconst __velarWebErrorNativePromise = globalThis.Promise;\nconst __velarWebErrorOwnSymbolsOperation = Object.getOwnPropertyDescriptor(Object, \"getOwnPropertySymbols\")?.value;\nconst __velarWebErrorFreezeOperation = Object.getOwnPropertyDescriptor(Object, \"freeze\")?.value;\nconst __velarWebErrorFiniteOperation = Object.getOwnPropertyDescriptor(Number, \"isFinite\")?.value;\nconst __velarWebErrorPromisePrototype = Object.getOwnPropertyDescriptor(__velarWebErrorNativePromise, \"prototype\")?.value;\nconst __velarWebErrorThenOperation = __velarWebErrorPromisePrototype\n  ? Object.getOwnPropertyDescriptor(__velarWebErrorPromisePrototype, \"then\")?.value\n  : null;\nfunction __velarWebErrorOwnSymbols(value) {\n  return __velarErrorApply(__velarWebErrorOwnSymbolsOperation, __velarWebErrorNativeObject, [value], \"Object.getOwnPropertySymbols\");\n}\nfunction __velarWebErrorFreeze(value) {\n  return __velarErrorApply(__velarWebErrorFreezeOperation, __velarWebErrorNativeObject, [value], \"Object.freeze\");\n}\nfunction __velarWebErrorFinite(value) {\n  return __velarErrorApply(__velarWebErrorFiniteOperation, __velarWebErrorNativeNumber, [value], \"Number.isFinite\");\n}\nfunction __velarObservePromise(value, onRejected) {\n  if ((typeof value !== \"object\" && typeof value !== \"function\") || value === null) return null;\n  try { return __velarErrorApply(__velarWebErrorThenOperation, value, [undefined, onRejected], \"Promise.then\"); }\n  catch { return null; }\n}\n";
/** Error normalization plus the Web-owned promise and freeze operations layered on it. */
export declare const WEB_ERROR_HOST_RUNTIME: string;
export declare const WEB_FOUNDATION_BODY: string;
/**
 * The reactive runtime an application installs once: the captured host ABI,
 * the flush budget and its runaway report, and the dependency graph itself.
 * `velar/app` ships it as a module; an emitted program inlines the same
 * bytes, because both are this constant.
 */
export declare const WEB_RUNTIME_FOUNDATION: string;
/**
 * The same foundation for a project build, where error normalization is
 * imported from the compiler-owned module instead of inlined.
 */
export declare const WEB_RUNTIME_FOUNDATION_SHARED_ERROR: string;
/**
 * `cssString` written as emitted-runtime JavaScript. The runtime spelling and
 * the compile-time spelling must produce the same text for the same input —
 * a Look string folded at compile time and the same string pushed through the
 * runtime are the same declaration — so they are published together.
 */
export declare const CSS_STRING_RUNTIME_BODY = "function __velarCssString(value) {\n  let text = \"\";\n  for (const character of value) {\n    const code = character.codePointAt(0);\n    if (character === \"\\\"\" || character === \"\\\\\") {\n      text += \"\\\\\" + character;\n      continue;\n    }\n    if (code < 0x20 || code === 0x7f) {\n      text += \"\\\\\" + code.toString(16).toUpperCase() + \" \";\n      continue;\n    }\n    text += character;\n  }\n  return \"\\\"\" + text + \"\\\"\";\n}\n";
export declare const CSS_STRING_RUNTIME: string;
/** Web-owned late-binding bridge to its optional immutable reactive runtime provider. */
export declare const VELAR_REACTIVE_BRIDGE_RUNTIME = "const __velarReactiveBridgeGlobal = globalThis;\nconst __velarReactiveBridgeNativeObject = globalThis.Object;\nconst __velarReactiveBridgeNativeSymbol = globalThis.Symbol;\nconst __velarReactiveBridgeNativeTypeError = globalThis.TypeError;\nconst __velarReactiveBridgeGetOwnPropertyDescriptor = __velarReactiveBridgeNativeObject.getOwnPropertyDescriptor;\nconst __velarReactiveBridgeGetPrototypeOf = __velarReactiveBridgeGetOwnPropertyDescriptor(__velarReactiveBridgeNativeObject, \"getPrototypeOf\")?.value;\nconst __velarReactiveBridgeIsExtensible = __velarReactiveBridgeGetOwnPropertyDescriptor(__velarReactiveBridgeNativeObject, \"isExtensible\")?.value;\nconst __velarReactiveBridgeOwnSymbols = __velarReactiveBridgeGetOwnPropertyDescriptor(__velarReactiveBridgeNativeObject, \"getOwnPropertySymbols\")?.value;\nconst __velarReactiveBridgeSymbolFor = __velarReactiveBridgeGetOwnPropertyDescriptor(__velarReactiveBridgeNativeSymbol, \"for\")?.value;\nif (typeof __velarReactiveBridgeGetOwnPropertyDescriptor !== \"function\" || typeof __velarReactiveBridgeGetPrototypeOf !== \"function\"\n  || typeof __velarReactiveBridgeIsExtensible !== \"function\" || typeof __velarReactiveBridgeOwnSymbols !== \"function\"\n  || typeof __velarReactiveBridgeSymbolFor !== \"function\") throw new __velarReactiveBridgeNativeTypeError(\"The JavaScript reactive bridge runtime is unavailable\");\nconst __velarReactiveRuntimeKey = __velarReactiveBridgeSymbolFor(\"velar.runtime.v1\");\nconst __velarReactiveIterateKey = __velarReactiveBridgeSymbolFor(\"velar.reactive.iterate.v1\");\nconst __velarReactiveStructureKey = __velarReactiveBridgeSymbolFor(\"velar.reactive.structure.v1\");\nlet __velarReactiveBridge = null;\nfunction __velarReactiveBridgeField(runtime, name) {\n  const descriptor = __velarReactiveBridgeGetOwnPropertyDescriptor(runtime, name);\n  if (!descriptor || !(\"value\" in descriptor) || descriptor.enumerable || descriptor.configurable || descriptor.writable) {\n    throw new __velarReactiveBridgeNativeTypeError(\"VelarScript reactive runtime field '\" + name + \"' is invalid\");\n  }\n  return descriptor.value;\n}\nfunction __velarResolveReactiveBridge() {\n  if (__velarReactiveBridge) return __velarReactiveBridge;\n  const descriptor = __velarReactiveBridgeGetOwnPropertyDescriptor(__velarReactiveBridgeGlobal, __velarReactiveRuntimeKey);\n  if (!descriptor) return null;\n  if (!(\"value\" in descriptor) || descriptor.enumerable || descriptor.configurable || descriptor.writable) {\n    throw new __velarReactiveBridgeNativeTypeError(\"VelarScript reactive runtime registry ownership is invalid\");\n  }\n  const runtime = descriptor.value;\n  if (!runtime || typeof runtime !== \"object\"\n    || __velarReactiveBridgeGetPrototypeOf(runtime) !== null\n    || __velarReactiveBridgeIsExtensible(runtime)\n    || __velarReactiveBridgeOwnSymbols(runtime).length > 0) {\n    throw new __velarReactiveBridgeNativeTypeError(\"VelarScript reactive runtime ownership is invalid\");\n  }\n  const version = __velarReactiveBridgeField(runtime, \"version\");\n  const toRaw = __velarReactiveBridgeField(runtime, \"toRaw\");\n  if (version !== \"0.12\") {\n    throw new __velarReactiveBridgeNativeTypeError(\"VelarScript reactive runtime schema \" + (typeof version === \"string\" ? version : \"(unknown)\") + \" does not match this module's schema 0.12; one build mixed two generations of @velarscript/* \u2014 run 'npm ls @velarscript/compiler' and pin one version\");\n  }\n  if (typeof toRaw !== \"function\") {\n    throw new __velarReactiveBridgeNativeTypeError(\"VelarScript reactive runtime values are invalid\");\n  }\n  __velarReactiveBridge = { runtime, toRaw };\n  return __velarReactiveBridge;\n}\nfunction __velarReactiveRaw(value) {\n  const bridge = __velarResolveReactiveBridge();\n  return bridge ? bridge.toRaw(value) : value;\n}\nfunction __velarHostRaw(value) { return __velarReactiveRaw(value); }\n";
/** Collection-only extension of the Web reactive bridge. */
export declare const VELAR_REACTIVE_COLLECTION_BRIDGE_RUNTIME = "let __velarReactiveCollectionBridge = null;\nfunction __velarResolveReactiveCollectionBridge() {\n  if (__velarReactiveCollectionBridge) return __velarReactiveCollectionBridge;\n  const bridge = __velarResolveReactiveBridge();\n  if (!bridge) return null;\n  const collectionRead = __velarReactiveBridgeField(bridge.runtime, \"collectionRead\");\n  const collectionTrigger = __velarReactiveBridgeField(bridge.runtime, \"collectionTrigger\");\n  const collectionUnlink = __velarReactiveBridgeField(bridge.runtime, \"collectionUnlink\");\n  const reactive = __velarReactiveBridgeField(bridge.runtime, \"reactive\");\n  const track = __velarReactiveBridgeField(bridge.runtime, \"track\");\n  if (typeof collectionRead !== \"function\" || typeof collectionTrigger !== \"function\"\n    || typeof collectionUnlink !== \"function\" || typeof reactive !== \"function\" || typeof track !== \"function\") {\n    throw new __velarReactiveBridgeNativeTypeError(\"VelarScript reactive collection runtime values are invalid\");\n  }\n  __velarReactiveCollectionBridge = { runtime: bridge.runtime, toRaw: bridge.toRaw, collectionRead, collectionTrigger, collectionUnlink, reactive, track };\n  return __velarReactiveCollectionBridge;\n}\nfunction __velarReactiveCollectionRead(value, key, child) {\n  if (child === undefined) child = null;\n  const bridge = __velarResolveReactiveCollectionBridge();\n  return bridge ? bridge.collectionRead(value, key, child) : child;\n}\nfunction __velarReactiveCollectionTrack(value, key = __velarReactiveIterateKey) {\n  const bridge = __velarResolveReactiveCollectionBridge();\n  if (bridge) bridge.track(bridge.toRaw(value), key);\n}\nfunction __velarReactiveCollectionLink(value, child) {\n  const bridge = __velarResolveReactiveCollectionBridge();\n  if (bridge) bridge.reactive(child, bridge.toRaw(value));\n}\nfunction __velarReactiveCollectionTrigger(value, key, iterate = true, structure = false, indexFrom = null, allKeys = false) {\n  const bridge = __velarResolveReactiveCollectionBridge();\n  if (bridge) bridge.collectionTrigger(value, key, iterate, structure, indexFrom, allKeys);\n}\nfunction __velarReactiveCollectionUnlink(value, child) {\n  const bridge = __velarResolveReactiveCollectionBridge();\n  if (bridge) bridge.collectionUnlink(value, child);\n}\n";
/** The shared reactive-bridge module a project build imports, bridge plus collections plus its export block. */
export declare const VELAR_REACTIVE_BRIDGE_MODULE_SOURCE: string;
export declare const VELAR_WEB_WORKER_RUNTIME = "import { workerEntries as __velarWorkerEntries } from \"velar/worker-manifest\";\nimport { Cancellation, CancellationError, TaskTimeoutError } from \"velar/task\";\nimport { Bytes as __velarWorkerBinaryRuntime } from \"velar/binary\";\n\nconst __velarNativeWorker = globalThis.Worker;\nconst __velarWorkerStates = new WeakMap();\nconst __velarWorkerPoolStates = new WeakMap();\nlet __velarWorkerServerInstalled = false;\nconst __velarWorkerStructuredClone = globalThis.structuredClone;\nconst __velarWorkerCancelGrace = 1000;\nfunction __velarWorkerInteger(value, minimum, maximum, name) { if (!Number.isSafeInteger(value) || value < minimum || value > maximum) throw new RangeError(name + \" must be an integer from \" + minimum + \" through \" + maximum); return value; }\nfunction __velarWorkerRuntimeType(value, name) { if ((typeof value !== \"object\" && typeof value !== \"function\") || value === null || typeof value.parse !== \"function\" || typeof value.is !== \"function\") throw new TypeError(name + \" must be a runtime Type\"); return value; }\nfunction __velarWorkerDuration(value) { if (value === null) return 0; if (typeof value !== \"string\") throw new TypeError(\"Worker timeout must be Duration or null\"); const match = /^([+-]?(?:\\d+(?:\\.\\d+)?|\\.\\d+))(ms|s)$/.exec(value); if (!match) throw new TypeError(\"Worker timeout must be Duration such as 200ms or 2s\"); const milliseconds = Number(match[1]) * (match[2] === \"s\" ? 1000 : 1); if (!Number.isFinite(milliseconds) || milliseconds < 0 || milliseconds > 2147483647) throw new RangeError(\"Worker timeout is outside the supported range\"); return milliseconds; }\nfunction __velarWorkerTransfer(value, adopt = false) {\n  const transfers = []; const buffers = new Set(); const objects = new Set(); const pending = [{ value, depth: 0 }]; let visited = 0; let transferBytes = 0;\n  while (pending.length > 0 && visited < 10000 && transfers.length < 1024) {\n    const current = pending.pop(); const item = current.value; visited += 1;\n    if (item === null || (typeof item !== \"object\" && typeof item !== \"function\") || objects.has(item)) continue; objects.add(item);\n    if (ArrayBuffer.isView(item)) { const supported = item instanceof Uint8Array || item instanceof Uint16Array || item instanceof Uint32Array || item instanceof Float32Array; const buffer = item.buffer; if (supported && buffer instanceof ArrayBuffer && item.byteOffset === 0 && item.byteLength === buffer.byteLength && transferBytes + buffer.byteLength <= 64 * 1024 * 1024) { if (adopt) __velarWorkerBinaryRuntime.__velarAdoptTransferredBuffer(item); if (buffer.byteLength > 0 && !buffers.has(buffer)) { buffers.add(buffer); transfers.push(buffer); transferBytes += buffer.byteLength; } } continue; }\n    if (current.depth >= 32) continue; const depth = current.depth + 1;\n    if (item instanceof Map) { for (const [key, nested] of item) pending.push({ value: key, depth }, { value: nested, depth }); continue; }\n    if (item instanceof Set) { for (const nested of item) pending.push({ value: nested, depth }); continue; }\n    for (const key of Object.keys(item)) pending.push({ value: item[key], depth });\n  }\n  return transfers;\n}\nfunction __velarWorkerOutbound(value, source) {\n  const transfers = __velarWorkerTransfer(value);\n  if (transfers.length === 0) return { value, transfers };\n  const sourceTransfers = new Set(__velarWorkerTransfer(source));\n  if (!transfers.some(buffer => sourceTransfers.has(buffer))) return { value, transfers };\n  if (typeof __velarWorkerStructuredClone !== \"function\") throw new Error(\"The structured clone API is unavailable\");\n  const snapshot = __velarWorkerStructuredClone(value);\n  return { value: snapshot, transfers: __velarWorkerTransfer(snapshot) };\n}\nfunction __velarWorkerInbound(Type, value) {\n  if (!Type.is(value)) return Type.parse(value);\n  __velarWorkerTransfer(value, true);\n  return value;\n}\nfunction __velarWorkerFailure(error) { return { name: typeof error?.name === \"string\" ? error.name : \"Error\", message: typeof error?.message === \"string\" ? error.message : String(error), stack: typeof error?.stack === \"string\" ? error.stack : \"\" }; }\nexport class WorkerBackpressureError extends Error { constructor(message = \"Worker queue is full\") { super(message); this.name = \"WorkerBackpressureError\"; } }\nexport class WorkerCallError extends Error { constructor(message = \"Worker call failed\") { super(message); this.name = \"WorkerCallError\"; } }\nexport class WorkerCrashedError extends Error { constructor(message = \"Worker crashed\") { super(message); this.name = \"WorkerCrashedError\"; } }\nexport class WorkerClosedError extends Error { constructor(message = \"Worker is closed\") { super(message); this.name = \"WorkerClosedError\"; } }\nfunction __velarWorkerRejectAll(state, failure) { if (state.closed) return; state.closed = true; for (const pending of state.pending.values()) { if (pending.timer) clearTimeout(pending.timer); pending.unsubscribe(); pending.reject(failure); } state.pending.clear(); for (const timer of state.abandoned.values()) clearTimeout(timer); state.abandoned.clear(); }\nfunction __velarWorkerCrash(state, failure) { __velarWorkerRejectAll(state, failure); state.instance.terminate(); }\nconst __velarWorkerPrototype = Object.freeze({\n  call(request, cancellation = null, timeout = null) {\n    const state = __velarWorkerStates.get(this); if (!state) throw new TypeError(\"Worker.call requires a Worker receiver\"); if (state.closed) return Promise.reject(new WorkerClosedError());\n    if (state.pending.size >= state.capacity) return Promise.reject(new WorkerBackpressureError(\"Worker queue capacity \" + state.capacity + \" is full\"));\n    if (cancellation !== null && !Cancellation.is(cancellation)) return Promise.reject(new TypeError(\"Worker cancellation must be Cancellation or null\"));\n    let validated; try { validated = state.RequestType.parse(request); } catch (error) { return Promise.reject(error); }\n    let outbound; try { outbound = __velarWorkerOutbound(validated, request); } catch (error) { return Promise.reject(error); }\n    const milliseconds = __velarWorkerDuration(timeout); const id = state.nextId++;\n    return new Promise((resolve, reject) => { const pending = { resolve, reject, cancel: null, reason: \"Worker call cancelled\", timeout, timer: null, unsubscribe: () => null }; state.pending.set(id, pending); state.instance.postMessage({ kind: \"call\", id, value: outbound.value }, outbound.transfers); if (cancellation !== null) pending.unsubscribe = Cancellation.__velarOn(cancellation, reason => { if (!state.pending.has(id) || pending.cancel) return; pending.cancel = \"cancel\"; pending.reason = reason ?? pending.reason; state.instance.postMessage({ kind: \"cancel\", id, reason: pending.reason }); }); if (milliseconds > 0) pending.timer = setTimeout(() => { if (!state.pending.has(id) || pending.cancel) return; state.pending.delete(id); pending.unsubscribe(); state.instance.postMessage({ kind: \"cancel\", id, reason: \"Worker call timed out\" }); state.abandoned.set(id, setTimeout(() => __velarWorkerCrash(state, new WorkerCrashedError(\"Worker did not acknowledge a cancelled call within \" + __velarWorkerCancelGrace + \"ms\")), __velarWorkerCancelGrace)); reject(new TaskTimeoutError(\"Worker call timed out after \" + timeout)); }, milliseconds); });\n  },\n  async close() { const state = __velarWorkerStates.get(this); if (!state) throw new TypeError(\"Worker.close requires a Worker receiver\"); if (state.closed) return null; __velarWorkerRejectAll(state, new WorkerClosedError()); state.instance.terminate(); return null; },\n});\nfunction __velarWorkerClient(name, RequestType, ResponseType, capacity) {\n  if (typeof __velarNativeWorker !== \"function\") throw new Error(\"The browser Worker API is unavailable\"); if (typeof name !== \"string\" || !Object.hasOwn(__velarWorkerEntries, name)) throw new RangeError(\"Unknown worker entry '\" + String(name) + \"'\"); RequestType = __velarWorkerRuntimeType(RequestType, \"Worker request Type\"); ResponseType = __velarWorkerRuntimeType(ResponseType, \"Worker response Type\"); capacity = __velarWorkerInteger(capacity, 1, 10000, \"Worker capacity\");\n  const instance = new __velarNativeWorker(new URL(\"../\" + __velarWorkerEntries[name], import.meta.url), { type: \"module\", name: \"velar:\" + name }); const value = Object.create(__velarWorkerPrototype); const state = { instance, RequestType, ResponseType, capacity, nextId: 1, pending: new Map(), abandoned: new Map(), closed: false }; __velarWorkerStates.set(value, state);\n  instance.addEventListener(\"message\", event => { const message = event.data; if (!message || !Number.isSafeInteger(message.id)) { __velarWorkerCrash(state, new WorkerCrashedError(\"Worker returned an invalid message\")); return; } const grace = state.abandoned.get(message.id); if (grace !== undefined) { clearTimeout(grace); state.abandoned.delete(message.id); } if (message.kind === \"cancel-ack\") return; const pending = state.pending.get(message.id); if (!pending) return; state.pending.delete(message.id); if (pending.timer) clearTimeout(pending.timer); pending.unsubscribe(); if (pending.cancel === \"cancel\") { pending.reject(new CancellationError(pending.reason)); return; } if (!message.ok) { const remote = message.error ?? {}; const failure = new WorkerCallError((remote.name ? remote.name + \": \" : \"\") + (remote.message ?? \"Worker call failed\")); if (typeof remote.stack === \"string\" && remote.stack) failure.stack += \"\\nRemote worker:\\n\" + remote.stack; pending.reject(failure); return; } try { pending.resolve(__velarWorkerInbound(state.ResponseType, message.value)); } catch (error) { pending.reject(error); } });\n  instance.addEventListener(\"error\", event => __velarWorkerCrash(state, new WorkerCrashedError(event.message || \"Worker crashed\"))); instance.addEventListener(\"messageerror\", () => __velarWorkerCrash(state, new WorkerCrashedError(\"Worker returned an unreadable message\"))); return Object.freeze(value);\n}\nconst __velarWorkerPoolPrototype = Object.freeze({\n  call(request, cancellation = null, timeout = null) { const state = __velarWorkerPoolStates.get(this); if (!state) throw new TypeError(\"WorkerPool.call requires a WorkerPool receiver\"); if (state.closed) return Promise.reject(new WorkerClosedError(\"Worker pool is closed\")); let total = 0; let selected = null; let load = 0; for (const item of state.workers) { const member = __velarWorkerStates.get(item); if (member.closed) continue; total += member.pending.size; if (selected === null || member.pending.size < load) { selected = item; load = member.pending.size; } } if (selected === null) return Promise.reject(new WorkerCrashedError(\"Worker pool has no live workers\")); if (total >= state.capacity) return Promise.reject(new WorkerBackpressureError(\"Worker pool queue capacity \" + state.capacity + \" is full\")); return selected.call(request, cancellation, timeout); },\n  broadcast(request, cancellation = null, timeout = null) { const state = __velarWorkerPoolStates.get(this); if (!state) throw new TypeError(\"WorkerPool.broadcast requires a WorkerPool receiver\"); if (state.closed) return Promise.reject(new WorkerClosedError(\"Worker pool is closed\")); const live = []; let total = 0; for (const item of state.workers) { const member = __velarWorkerStates.get(item); if (member.closed) continue; live.push(item); total += member.pending.size; if (member.pending.size >= member.capacity) return Promise.reject(new WorkerBackpressureError(\"Worker pool member queue capacity \" + member.capacity + \" is full\")); } if (live.length === 0) return Promise.reject(new WorkerCrashedError(\"Worker pool has no live workers\")); if (total + live.length > state.capacity) return Promise.reject(new WorkerBackpressureError(\"Worker pool queue capacity \" + state.capacity + \" cannot accept a broadcast to \" + live.length + \" workers\")); return Promise.all(live.map(item => item.call(request, cancellation, timeout))); },\n  async close() { const state = __velarWorkerPoolStates.get(this); if (!state) throw new TypeError(\"WorkerPool.close requires a WorkerPool receiver\"); if (state.closed) return null; state.closed = true; await Promise.all(state.workers.map(item => item.close())); return null; },\n});\nconst __velarWorkerType = Object.freeze({ is(value) { return __velarWorkerStates.has(value); }, parse(value) { if (!this.is(value)) throw new TypeError(\"Value does not match Worker\"); return value; } });\nconst __velarWorkerPoolType = Object.freeze({ is(value) { return __velarWorkerPoolStates.has(value); }, parse(value) { if (!this.is(value)) throw new TypeError(\"Value does not match WorkerPool\"); return value; } });\nexport const Worker = Object.freeze({ ...__velarWorkerType, of() { return __velarWorkerType; } }); export const WorkerPool = Object.freeze({ ...__velarWorkerPoolType, of() { return __velarWorkerPoolType; } });\nexport function worker(name, RequestType, ResponseType, capacity = 64) { return __velarWorkerClient(name, RequestType, ResponseType, capacity); }\nexport function workerPool(name, RequestType, ResponseType, size, capacity = 256) { size = __velarWorkerInteger(size, 1, 32, \"Worker pool size\"); capacity = __velarWorkerInteger(capacity, size, 10000, \"Worker pool capacity\"); const workers = Array.from({ length: size }, () => __velarWorkerClient(name, RequestType, ResponseType, Math.ceil(capacity / size))); const value = Object.create(__velarWorkerPoolPrototype); __velarWorkerPoolStates.set(value, { workers, capacity, closed: false }); return Object.freeze(value); }\nexport function serveWorker(RequestType, ResponseType, handler, capacity = 64) {\n  if (__velarWorkerServerInstalled) throw new Error(\"A worker entry may call serveWorker() only once\"); RequestType = __velarWorkerRuntimeType(RequestType, \"Worker request Type\"); ResponseType = __velarWorkerRuntimeType(ResponseType, \"Worker response Type\"); if (typeof handler !== \"function\") throw new TypeError(\"serveWorker handler must be an async function\"); capacity = __velarWorkerInteger(capacity, 1, 10000, \"Worker capacity\"); __velarWorkerServerInstalled = true;\n  const queue = []; const active = new Map(); let running = false; const drain = async () => { if (running) return; running = true; while (queue.length) { const message = queue.shift(); const cancellation = Cancellation.__velarCreate(); active.set(message.id, cancellation); try { const request = __velarWorkerInbound(RequestType, message.value); const handled = await handler(request, cancellation); const result = ResponseType.parse(handled); const outbound = __velarWorkerOutbound(result, handled); globalThis.postMessage({ id: message.id, ok: true, value: outbound.value }, { transfer: outbound.transfers }); } catch (error) { globalThis.postMessage({ id: message.id, ok: false, error: __velarWorkerFailure(error) }); } finally { active.delete(message.id); } } running = false; };\n  globalThis.addEventListener(\"message\", event => { const message = event.data; if (!message || !Number.isSafeInteger(message.id)) return; if (message.kind === \"cancel\") { globalThis.postMessage({ id: message.id, kind: \"cancel-ack\" }); const cancellation = active.get(message.id); if (cancellation) Cancellation.__velarCancel(cancellation, typeof message.reason === \"string\" ? message.reason : \"Worker call cancelled\"); else { const index = queue.findIndex(item => item.id === message.id); if (index >= 0) { queue.splice(index, 1); globalThis.postMessage({ id: message.id, ok: false, error: __velarWorkerFailure(new CancellationError(typeof message.reason === \"string\" ? message.reason : \"Worker call cancelled\")) }); } } return; } if (message.kind !== \"call\") return; if (queue.length + active.size >= capacity) { globalThis.postMessage({ id: message.id, ok: false, error: __velarWorkerFailure(new WorkerBackpressureError()) }); return; } queue.push(message); drain(); }); return null;\n}\n";
export declare const VELAR_WEB_WEBSOCKET_RUNTIME = "const __velarNativeWebSocket = globalThis.WebSocket;\nconst __velarWebSocketConnections = new WeakMap();\nfunction __velarWsInteger(value, fallback, minimum, maximum, name) { if (value === undefined || value === null) return fallback; if (!Number.isSafeInteger(value) || value < minimum || value > maximum) throw new RangeError(name + \" must be an integer from \" + minimum + \" through \" + maximum); return value; }\nfunction __velarWsDuration(value, fallback) { if (value === undefined || value === null) return fallback; if (typeof value !== \"string\") throw new TypeError(\"WebSocket timeout must be Duration\"); const match = /^([+-]?(?:\\d+(?:\\.\\d+)?|\\.\\d+))(ms|s)$/.exec(value); if (!match) throw new TypeError(\"WebSocket timeout must be Duration such as 5s\"); const result = Number(match[1]) * (match[2] === \"s\" ? 1000 : 1); if (!Number.isFinite(result) || result < 0 || result > 2147483647) throw new RangeError(\"WebSocket timeout is outside the supported range\"); return result; }\nfunction __velarWsOptions(options = {}) { if (options === null || typeof options !== \"object\" || Array.isArray(options)) throw new TypeError(\"WebSocket options must be a record\"); return { maxMessageBytes: __velarWsInteger(options.maxMessageBytes, 16 * 1024 * 1024, 1, 64 * 1024 * 1024, \"maxMessageBytes\"), maxQueuedMessages: __velarWsInteger(options.maxQueuedMessages, 256, 1, 10000, \"maxQueuedMessages\"), maxQueuedBytes: __velarWsInteger(options.maxQueuedBytes, 16 * 1024 * 1024, 1, 64 * 1024 * 1024, \"maxQueuedBytes\"), maxPendingSendBytes: __velarWsInteger(options.maxPendingSendBytes, 16 * 1024 * 1024, 1, 64 * 1024 * 1024, \"maxPendingSendBytes\") }; }\nfunction __velarWsUtf8(value) { return new TextEncoder().encode(value).byteLength; }\nfunction __velarWsBytes(value) { if (!(value instanceof Uint8Array)) return null; const output = new Uint8Array(value.byteLength); output.set(value); return output; }\nexport class WebSocketBackpressureError extends Error { constructor(message = \"WebSocket backpressure limit exceeded\") { super(message); this.name = \"WebSocketBackpressureError\"; } }\nexport class WebSocketClosedError extends Error { constructor(message = \"WebSocket is closed\") { super(message); this.name = \"WebSocketClosedError\"; } }\nexport class WebSocketProtocolError extends Error { constructor(message = \"WebSocket protocol error\") { super(message); this.name = \"WebSocketProtocolError\"; } }\nexport class WebSocketTimeoutError extends Error { constructor(message = \"WebSocket timed out\") { super(message); this.name = \"WebSocketTimeoutError\"; } }\n// Bytes that already left the socket stay sent, so a waiter past the flush watermark resolves even when the connection finishes in the same turn; only what is still buffered fails.\nfunction __velarWsFailSends(state) { if (state.drainTimer !== null) { clearTimeout(state.drainTimer); state.drainTimer = null; } const flushed = state.sentBytes - state.socket.bufferedAmount; for (const waiter of state.sendWaiters) { if (flushed >= waiter.target) waiter.resolve(null); else waiter.reject(new WebSocketClosedError()); } state.sendWaiters.clear(); }\nfunction __velarWsWatchDrain(state) { if (state.drainTimer !== null || state.sendWaiters.size === 0) return; state.drainTimer = setTimeout(() => __velarWsDrain(state), state.drainDelay); }\nfunction __velarWsDrain(state) { state.drainTimer = null; if (state.finished) { __velarWsFailSends(state); return; } const flushed = state.sentBytes - state.socket.bufferedAmount; let settled = false; for (const waiter of state.sendWaiters) if (flushed >= waiter.target) { state.sendWaiters.delete(waiter); waiter.resolve(null); settled = true; } state.drainDelay = settled ? 1 : Math.min(state.drainDelay * 2, 32); __velarWsWatchDrain(state); }\nfunction __velarWsResolveClose(state, code = 1006, reason = \"\") { if (state.closeInfo !== null) return; state.closeInfo = Object.freeze({code, reason}); state.resolveCloseInfo(state.closeInfo); }\nfunction __velarWsFinish(state, code = 1000, reason = \"\") { __velarWsResolveClose(state, code, reason); if (state.finished) return; state.finished = true; if (state.waiter) { state.waiter.resolve(null); state.waiter = null; } __velarWsFailSends(state); }\nfunction __velarWsAbort(state, code = 1006, reason = \"\") { __velarWsResolveClose(state, code, reason); state.finished = true; state.queue.length = 0; state.queuedBytes = 0; if (state.waiter) { state.waiter.resolve(null); state.waiter = null; } __velarWsFailSends(state); }\nfunction __velarWsRejectReceive(state, socket, code, reason) { __velarWsAbort(state, code, reason); socket.close(code, reason); }\nfunction __velarWsWrap(socket, options) { let resolveCloseInfo; const closeInfoPromise = new Promise(resolve => { resolveCloseInfo = resolve; }); const value = Object.create(__velarWsConnectionPrototype); value.origin = null; const state = { socket, options, queue: [], queuedBytes: 0, waiter: null, finished: false, closePromise: null, closeInfo: null, closeInfoPromise, resolveCloseInfo, sendWaiters: new Set(), sentBytes: 0, drainTimer: null, drainDelay: 1 }; __velarWebSocketConnections.set(value, state); socket.binaryType = \"arraybuffer\";\n  socket.addEventListener(\"message\", event => { if (state.finished) return; let message; let size; if (typeof event.data === \"string\") { size = __velarWsUtf8(event.data); if (size > options.maxMessageBytes) { __velarWsRejectReceive(state, socket, 4009, \"Message too large\"); return; } message = event.data; } else if (event.data instanceof ArrayBuffer) { size = event.data.byteLength; if (size > options.maxMessageBytes) { __velarWsRejectReceive(state, socket, 4009, \"Message too large\"); return; } message = new Uint8Array(event.data); } else { __velarWsRejectReceive(state, socket, 4003, \"Unsupported message type\"); return; } if (state.waiter) { const waiter = state.waiter; state.waiter = null; waiter.resolve(message); } else if (state.queue.length >= options.maxQueuedMessages || state.queuedBytes + size > options.maxQueuedBytes) __velarWsRejectReceive(state, socket, 4009, \"Unread message queue full\"); else { state.queue.push(message); state.queuedBytes += size; } });\n  socket.addEventListener(\"close\", event => __velarWsFinish(state, event.code, event.reason)); socket.addEventListener(\"error\", () => { if (state.waiter) { state.waiter.reject(new WebSocketProtocolError()); state.waiter = null; } __velarWsAbort(state); }); return Object.freeze(value); }\nconst __velarWsConnectionPrototype = Object.freeze({\n  state() { const state = __velarWebSocketConnections.get(this); if (!state) throw new TypeError(\"WebSocket state requires a connection\"); return state.socket.readyState === __velarNativeWebSocket.CONNECTING ? \"connecting\" : state.socket.readyState === __velarNativeWebSocket.OPEN ? \"open\" : state.socket.readyState === __velarNativeWebSocket.CLOSING ? \"closing\" : \"closed\"; },\n  send(message) { const state = __velarWebSocketConnections.get(this); if (!state) throw new TypeError(\"WebSocket.send requires a connection\"); if (state.socket.readyState !== __velarNativeWebSocket.OPEN) return Promise.reject(new WebSocketClosedError()); const bytes = typeof message === \"string\" ? null : __velarWsBytes(message); if (bytes === null && typeof message !== \"string\") return Promise.reject(new TypeError(\"WebSocket.send requires text or Bytes\")); const size = bytes?.byteLength ?? __velarWsUtf8(message); if (size > state.options.maxMessageBytes) return Promise.reject(new RangeError(\"WebSocket message exceeds maxMessageBytes\")); if (state.socket.bufferedAmount + size > state.options.maxPendingSendBytes) return Promise.reject(new WebSocketBackpressureError()); state.socket.send(bytes ?? message); state.sentBytes += size; const target = state.sentBytes; return new Promise((resolve, reject) => { if (state.finished) { reject(new WebSocketClosedError()); return; } if (state.sentBytes - state.socket.bufferedAmount >= target) { resolve(null); return; } state.sendWaiters.add({ resolve, reject, target }); state.drainDelay = 1; __velarWsWatchDrain(state); }); },\n  next() { const state = __velarWebSocketConnections.get(this); if (!state) throw new TypeError(\"WebSocket.next requires a connection\"); if (state.queue.length) { const message = state.queue.shift(); state.queuedBytes -= typeof message === \"string\" ? __velarWsUtf8(message) : message.byteLength; return Promise.resolve(message); } if (state.finished) return Promise.resolve(null); if (state.waiter) return Promise.reject(new WebSocketBackpressureError(\"Only one WebSocket.next call may wait at a time\")); return new Promise((resolve, reject) => { state.waiter = { resolve, reject }; }); },\n  closeInfo() { const state = __velarWebSocketConnections.get(this); if (!state) throw new TypeError(\"WebSocket.closeInfo requires a connection\"); return state.closeInfoPromise; },\n  close(code = 1000, reason = \"\") { const state = __velarWebSocketConnections.get(this); if (!state) throw new TypeError(\"WebSocket.close requires a connection\"); if (!Number.isSafeInteger(code) || code < 1000 || code > 4999) return Promise.reject(new RangeError(\"WebSocket close code must be from 1000 through 4999\")); if (typeof reason !== \"string\" || __velarWsUtf8(reason) > 123) return Promise.reject(new RangeError(\"WebSocket close reason cannot exceed 123 UTF-8 bytes\")); if (state.finished) return Promise.resolve(null); if (!state.closePromise) { state.closePromise = new Promise(resolve => state.socket.addEventListener(\"close\", () => resolve(null), { once: true })); state.socket.close(code, reason); } return state.closePromise; },\n});\nconst __velarWsCloseType = Object.freeze({ is(value) { return value !== null && typeof value === \"object\" && Number.isSafeInteger(value.code) && typeof value.reason === \"string\"; }, parse(value) { if (!this.is(value)) throw new TypeError(\"Value does not match WebSocketClose\"); return value; } });\nconst __velarWsConnectionType = Object.freeze({ is(value) { return __velarWebSocketConnections.has(value); }, parse(value) { if (!this.is(value)) throw new TypeError(\"Value does not match WebSocketConnection\"); return value; } });\nexport const WebSocketConnection = __velarWsConnectionType;\nexport const WebSocketClose = __velarWsCloseType;\nexport function connect(url, options = {}) { if (typeof __velarNativeWebSocket !== \"function\") return Promise.reject(new Error(\"The browser WebSocket API is unavailable\")); if (typeof url !== \"string\" || !/^wss?:\\/\\//u.test(url)) return Promise.reject(new TypeError(\"WebSocket URL must start with ws:// or wss://\")); const limits = __velarWsOptions(options); const timeout = __velarWsDuration(options.timeout, 10000); return new Promise((resolve, reject) => { const socket = new __velarNativeWebSocket(url); const timer = setTimeout(() => { socket.close(); reject(new WebSocketTimeoutError(\"WebSocket connection timed out\")); }, timeout); socket.addEventListener(\"open\", () => { clearTimeout(timer); resolve(__velarWsWrap(socket, limits)); }, { once: true }); socket.addEventListener(\"error\", () => { clearTimeout(timer); reject(new WebSocketProtocolError(\"WebSocket connection failed\")); }, { once: true }); }); }\n";
/** Browser-owned resilient realtime client layered over `velar/websocket`. */
export declare const VELAR_WEB_REALTIME_CLIENT_RUNTIME = "import { WebSocketConnection as __velarRealtimeConnection, connect as __velarRealtimeConnect } from \"velar/websocket\";\n\nconst __velarRealtimeClients = new WeakMap();\nconst __velarRealtimeApply = Reflect.apply;\nconst __velarRealtimeArrayIsArray = Array.isArray;\nconst __velarRealtimeArrayPush = Array.prototype.push;\nconst __velarRealtimeFreeze = Object.freeze;\nconst __velarRealtimeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nconst __velarRealtimeGetOwnPropertyNames = Object.getOwnPropertyNames;\nconst __velarRealtimeArrayIncludes = Array.prototype.includes;\nconst __velarRealtimeNumberIsFinite = Number.isFinite;\nconst __velarRealtimeNumberIsSafeInteger = Number.isSafeInteger;\nconst __velarRealtimeMathMax = Math.max;\nconst __velarRealtimeMathRound = Math.round;\nconst __velarRealtimeRandom = Math.random;\nconst __velarRealtimeSetTimeout = globalThis.setTimeout;\nconst __velarRealtimeClearTimeout = globalThis.clearTimeout;\nconst __velarRealtimePromise = Promise;\nconst __velarRealtimePromiseReject = Promise.reject;\nconst __velarRealtimePromiseResolve = Promise.resolve;\nconst __velarRealtimeStringCharCodeAt = String.prototype.charCodeAt;\nconst __velarRealtimeWeakMapGet = WeakMap.prototype.get;\nconst __velarRealtimeWeakMapHas = WeakMap.prototype.has;\nconst __velarRealtimeWeakMapSet = WeakMap.prototype.set;\nconst __velarRealtimeOptionNames = __velarRealtimeFreeze([\"connectTimeout\", \"maxMessageBytes\", \"maxQueuedMessages\", \"maxQueuedBytes\", \"maxPendingSendBytes\", \"reconnectDelays\", \"reconnectJitter\", \"retryInitial\"]);\nconst __velarRealtimeDefaultDelays = __velarRealtimeFreeze([0, 1000, 2000, 5000, 10000, 30000]);\n\nexport class RealtimeUnavailableError extends Error {\n  constructor(message = \"Realtime client is not connected\") { super(message); this.name = \"RealtimeUnavailableError\"; }\n}\n\nfunction __velarRealtimeCall(operation, receiver, arguments_) { return __velarRealtimeApply(operation, receiver, arguments_); }\nfunction __velarRealtimeRejected(failure) { return __velarRealtimeCall(__velarRealtimePromiseReject, __velarRealtimePromise, [failure]); }\nfunction __velarRealtimeResolved(value) { return __velarRealtimeCall(__velarRealtimePromiseResolve, __velarRealtimePromise, [value]); }\n\nfunction __velarRealtimeRecord(value, label, allowed = null) {\n  if (value === null || typeof value !== \"object\" || __velarRealtimeCall(__velarRealtimeArrayIsArray, Array, [value])) throw new TypeError(label + \" must be a record\");\n  const names = __velarRealtimeCall(__velarRealtimeGetOwnPropertyNames, Object, [value]);\n  for (let index = 0; index < names.length; index += 1) {\n    const name = names[index];\n    if (allowed !== null && !__velarRealtimeCall(__velarRealtimeArrayIncludes, allowed, [name])) throw new TypeError(label + \" has unknown field '\" + name + \"'\");\n    const descriptor = __velarRealtimeCall(__velarRealtimeGetOwnPropertyDescriptor, Object, [value, name]);\n    if (!descriptor?.enumerable || !(\"value\" in descriptor)) throw new TypeError(label + \" fields must be enumerable data values\");\n  }\n  return value;\n}\n\nfunction __velarRealtimeOption(options, name) {\n  const descriptor = __velarRealtimeCall(__velarRealtimeGetOwnPropertyDescriptor, Object, [options, name]);\n  return descriptor && \"value\" in descriptor ? descriptor.value : undefined;\n}\n\nfunction __velarRealtimeInteger(value, fallback, minimum, maximum, label) {\n  if (value === undefined || value === null) return fallback;\n  if (!__velarRealtimeCall(__velarRealtimeNumberIsSafeInteger, Number, [value]) || value < minimum || value > maximum) throw new RangeError(label + \" must be an integer from \" + minimum + \" through \" + maximum);\n  return value;\n}\n\nfunction __velarRealtimeDuration(value, fallback, label) {\n  if (value === undefined || value === null) return fallback;\n  if (typeof value !== \"string\") throw new TypeError(label + \" must be Duration\");\n  const match = /^([+-]?(?:\\d+(?:\\.\\d+)?|\\.\\d+))(ms|s)$/.exec(value);\n  if (!match) throw new TypeError(label + \" must be Duration such as 5s\");\n  const milliseconds = Number(match[1]) * (match[2] === \"s\" ? 1000 : 1);\n  if (!__velarRealtimeCall(__velarRealtimeNumberIsFinite, Number, [milliseconds]) || milliseconds < 0 || milliseconds > 2147483647) throw new RangeError(label + \" is outside the supported range\");\n  return milliseconds;\n}\n\nfunction __velarRealtimeDelays(value) {\n  if (value === undefined || value === null) return __velarRealtimeDefaultDelays;\n  if (!__velarRealtimeCall(__velarRealtimeArrayIsArray, Array, [value])) throw new TypeError(\"Realtime reconnectDelays must be List<Duration>\");\n  if (value.length > 32) throw new RangeError(\"Realtime reconnectDelays cannot contain more than 32 entries\");\n  const delays = [];\n  for (let index = 0; index < value.length; index += 1) {\n    const descriptor = __velarRealtimeCall(__velarRealtimeGetOwnPropertyDescriptor, Object, [value, index]);\n    if (!descriptor?.enumerable || !(\"value\" in descriptor)) throw new TypeError(\"Realtime reconnectDelays must be a dense List<Duration>\");\n    __velarRealtimeCall(__velarRealtimeArrayPush, delays, [__velarRealtimeDuration(descriptor.value, 0, \"Realtime reconnect delay\")]);\n  }\n  return __velarRealtimeFreeze(delays);\n}\n\nfunction __velarRealtimeOptions(value = {}) {\n  const options = __velarRealtimeRecord(value, \"Realtime client options\", __velarRealtimeOptionNames);\n  const jitter = __velarRealtimeOption(options, \"reconnectJitter\") ?? 0.2;\n  if (typeof jitter !== \"number\" || !__velarRealtimeCall(__velarRealtimeNumberIsFinite, Number, [jitter]) || jitter < 0 || jitter > 1) throw new RangeError(\"Realtime reconnectJitter must be from 0 through 1\");\n  const retryInitial = __velarRealtimeOption(options, \"retryInitial\") ?? false;\n  if (typeof retryInitial !== \"boolean\") throw new TypeError(\"Realtime retryInitial must be bool\");\n  return __velarRealtimeFreeze({\n    connectTimeout: __velarRealtimeDuration(__velarRealtimeOption(options, \"connectTimeout\"), 10000, \"Realtime connectTimeout\"),\n    maxMessageBytes: __velarRealtimeInteger(__velarRealtimeOption(options, \"maxMessageBytes\"), 16 * 1024 * 1024, 1, 64 * 1024 * 1024, \"Realtime maxMessageBytes\"),\n    maxQueuedMessages: __velarRealtimeInteger(__velarRealtimeOption(options, \"maxQueuedMessages\"), 256, 1, 10000, \"Realtime maxQueuedMessages\"),\n    maxQueuedBytes: __velarRealtimeInteger(__velarRealtimeOption(options, \"maxQueuedBytes\"), 16 * 1024 * 1024, 1, 64 * 1024 * 1024, \"Realtime maxQueuedBytes\"),\n    maxPendingSendBytes: __velarRealtimeInteger(__velarRealtimeOption(options, \"maxPendingSendBytes\"), 16 * 1024 * 1024, 1, 64 * 1024 * 1024, \"Realtime maxPendingSendBytes\"),\n    reconnectDelays: __velarRealtimeDelays(__velarRealtimeOption(options, \"reconnectDelays\")),\n    reconnectJitter: jitter,\n    retryInitial,\n  });\n}\n\nfunction __velarRealtimeCodec(value) {\n  const codec = __velarRealtimeRecord(value, \"Realtime codec\", [\"decode\", \"encode\"]);\n  const decode = __velarRealtimeOption(codec, \"decode\");\n  const encode = __velarRealtimeOption(codec, \"encode\");\n  if (typeof decode !== \"function\" || typeof encode !== \"function\") throw new TypeError(\"Realtime codec requires decode and encode functions\");\n  return __velarRealtimeFreeze({decode, encode});\n}\n\nfunction __velarRealtimeCallback(value, label) {\n  if (value !== null && typeof value !== \"function\") throw new TypeError(label + \" must be a function or null\");\n  return value;\n}\n\nfunction __velarRealtimeFailure(phase, failure, recoverable) {\n  const error = failure instanceof Error ? failure : new Error(\"Realtime \" + phase + \" failed\");\n  return __velarRealtimeFreeze({phase, error, recoverable});\n}\n\nfunction __velarRealtimeUtf8Size(value, maximum) {\n  let size = 0;\n  for (let index = 0; index < value.length; index += 1) {\n    const code = __velarRealtimeCall(__velarRealtimeStringCharCodeAt, value, [index]);\n    if (code < 0x80) size += 1;\n    else if (code < 0x800) size += 2;\n    else if (code >= 0xd800 && code <= 0xdbff && index + 1 < value.length) {\n      const following = __velarRealtimeCall(__velarRealtimeStringCharCodeAt, value, [index + 1]);\n      if (following >= 0xdc00 && following <= 0xdfff) { size += 4; index += 1; }\n      else size += 3;\n    } else size += 3;\n    if (size > maximum) return size;\n  }\n  return size;\n}\n\nfunction __velarRealtimeClientState(client) {\n  const state = __velarRealtimeCall(__velarRealtimeWeakMapGet, __velarRealtimeClients, [client]);\n  if (!state) throw new TypeError(\"RealtimeClient method requires a RealtimeClient receiver\");\n  return state;\n}\n\nfunction __velarRealtimeTransition(client, next) {\n  const state = __velarRealtimeClientState(client);\n  if (state.status === next) return __velarRealtimeResolved(null);\n  state.status = next;\n  if (state.stateChanged === null) return __velarRealtimeResolved(null);\n  return __velarRealtimeResolved(state.stateChanged(client, next));\n}\n\nfunction __velarRealtimeWait(state, milliseconds) {\n  if (milliseconds <= 0) return __velarRealtimeResolved(null);\n  return new __velarRealtimePromise(resolve => {\n    const timer = __velarRealtimeSetTimeout(() => {\n      if (state.delayWake === null) return;\n      state.delayWake = null;\n      resolve(null);\n    }, milliseconds);\n    state.delayWake = () => {\n      __velarRealtimeClearTimeout(timer);\n      state.delayWake = null;\n      resolve(null);\n    };\n  });\n}\n\nfunction __velarRealtimeReconnectDelay(state, attempt) {\n  if (attempt >= state.options.reconnectDelays.length) return null;\n  const base = state.options.reconnectDelays[attempt];\n  if (base === 0 || state.options.reconnectJitter === 0) return base;\n  const spread = base * state.options.reconnectJitter;\n  const rounded = __velarRealtimeCall(__velarRealtimeMathRound, Math, [base - spread + __velarRealtimeCall(__velarRealtimeRandom, Math, []) * spread * 2]);\n  return __velarRealtimeCall(__velarRealtimeMathMax, Math, [0, rounded]);\n}\n\nasync function __velarRealtimeFailureAction(state, client, failure) {\n  if (state.failed === null) return failure.recoverable ? \"reconnect\" : \"stop\";\n  const action = await state.failed(failure, client);\n  if (action !== \"continue\" && action !== \"reconnect\" && action !== \"stop\") throw new TypeError(\"Realtime client failure callback returned an invalid action\");\n  if (!failure.recoverable && action === \"continue\") return \"stop\";\n  return action;\n}\n\nfunction __velarRealtimeResolveOpen(state) {\n  const waiters = state.openWaiters;\n  state.openWaiters = [];\n  for (let index = 0; index < waiters.length; index += 1) waiters[index].resolve(state.generation);\n}\n\nfunction __velarRealtimeRejectOpen(state, failure) {\n  const waiters = state.openWaiters;\n  state.openWaiters = [];\n  for (let index = 0; index < waiters.length; index += 1) waiters[index].reject(failure);\n}\n\nasync function __velarRealtimeCloseFailedConnection(state, client) {\n  const connection = state.connection;\n  if (connection === null) return;\n  try { await connection.close(1011, \"Realtime client callback failed\"); } catch {}\n  let close = {code: 1006, reason: \"Realtime client callback failed\"};\n  try { close = await connection.closeInfo(); } catch {}\n  state.connection = null;\n  if (state.closed !== null) {\n    try { await state.closed(client, close); } catch {}\n  }\n}\n\nasync function __velarRealtimeRun(client) {\n  const state = __velarRealtimeClientState(client);\n  let reconnectAttempt = 0;\n  let openedOnce = false;\n  try {\n    while (!state.stopping) {\n      await __velarRealtimeTransition(client, openedOnce ? \"reconnecting\" : \"connecting\");\n      let connection;\n      try {\n        const url = typeof state.url === \"function\" ? state.url() : state.url;\n        if (typeof url !== \"string\") throw new TypeError(\"Realtime URL provider must return text\");\n        connection = await __velarRealtimeConnect(url, {\n          timeout: state.options.connectTimeout + \"ms\",\n          maxMessageBytes: state.options.maxMessageBytes,\n          maxQueuedMessages: state.options.maxQueuedMessages,\n          maxQueuedBytes: state.options.maxQueuedBytes,\n          maxPendingSendBytes: state.options.maxPendingSendBytes,\n        });\n      } catch (failure) {\n        const problem = __velarRealtimeFailure(\"connect\", failure, true);\n        const action = await __velarRealtimeFailureAction(state, client, problem);\n        const canRetry = action === \"reconnect\" && (openedOnce || state.options.retryInitial);\n        const delay = canRetry ? __velarRealtimeReconnectDelay(state, reconnectAttempt) : null;\n        if (delay === null) { __velarRealtimeRejectOpen(state, problem.error); break; }\n        reconnectAttempt += 1;\n        await __velarRealtimeWait(state, delay);\n        continue;\n      }\n      state.connection = __velarRealtimeConnection.parse(connection);\n      if (state.stopping) { await connection.close(1000, \"Realtime client stopped\"); break; }\n      state.generation += 1;\n      reconnectAttempt = 0;\n      await __velarRealtimeTransition(client, \"open\");\n      try {\n        if (state.opened !== null) await state.opened(client, __velarRealtimeFreeze({generation: state.generation, reconnected: openedOnce}));\n      } catch (failure) {\n        const problem = __velarRealtimeFailure(\"opened\", failure, false);\n        await __velarRealtimeFailureAction(state, client, problem);\n        __velarRealtimeRejectOpen(state, problem.error);\n        await connection.close(1011, \"Realtime client setup failed\");\n        break;\n      }\n      openedOnce = true;\n      __velarRealtimeResolveOpen(state);\n      let reconnect = false;\n      while (!state.stopping) {\n        let wire;\n        try { wire = await connection.next(); }\n        catch (failure) {\n          const action = await __velarRealtimeFailureAction(state, client, __velarRealtimeFailure(\"transport\", failure, true));\n          reconnect = action === \"reconnect\";\n          break;\n        }\n        if (wire === null) break;\n        let message;\n        try { message = __velarRealtimeCall(state.codec.decode, undefined, [wire]); }\n        catch (failure) {\n          const action = await __velarRealtimeFailureAction(state, client, __velarRealtimeFailure(\"decode\", failure, true));\n          if (action === \"continue\") continue;\n          reconnect = action === \"reconnect\";\n          await connection.close(1007, \"Realtime message is invalid\");\n          break;\n        }\n        try { await state.receive(message, client); }\n        catch (failure) {\n          const action = await __velarRealtimeFailureAction(state, client, __velarRealtimeFailure(\"receive\", failure, true));\n          if (action === \"continue\") continue;\n          reconnect = action === \"reconnect\";\n          await connection.close(1011, \"Realtime message handler failed\");\n          break;\n        }\n      }\n      const close = await connection.closeInfo();\n      state.connection = null;\n      if (state.closed !== null) await state.closed(client, close);\n      if (state.stopping) break;\n      if (!reconnect) reconnect = close.code === 1001 || close.code === 1006 || close.code === 1011 || close.code === 1012 || close.code === 1013;\n      const delay = reconnect ? __velarRealtimeReconnectDelay(state, reconnectAttempt) : null;\n      if (delay === null) break;\n      reconnectAttempt += 1;\n      await __velarRealtimeWait(state, delay);\n    }\n  } catch (failure) {\n    const error = failure instanceof Error ? failure : new Error(\"Realtime client failed\");\n    await __velarRealtimeCloseFailedConnection(state, client);\n    __velarRealtimeRejectOpen(state, error);\n    state.runnerFailure = error;\n  } finally {\n    state.connection = null;\n    state.stopping = true;\n    try { await __velarRealtimeTransition(client, \"closed\"); }\n    catch (failure) { if (state.runnerFailure === null) state.runnerFailure = failure instanceof Error ? failure : new Error(\"Realtime state callback failed\"); }\n    __velarRealtimeRejectOpen(state, new RealtimeUnavailableError(\"Realtime client closed before opening\"));\n    state.resolveDone(null);\n  }\n}\n\nconst __velarRealtimeClientPrototype = __velarRealtimeFreeze({\n  state() { return __velarRealtimeClientState(this).status; },\n  generation() { return __velarRealtimeClientState(this).generation; },\n  start() {\n    const state = __velarRealtimeClientState(this);\n    if (state.status === \"closed\") return __velarRealtimeRejected(new RealtimeUnavailableError(\"Realtime client is closed\"));\n    const opening = this.whenOpen();\n    if (state.runner === null) state.runner = __velarRealtimeRun(this);\n    return (async () => { await opening; return null; })();\n  },\n  whenOpen() {\n    const state = __velarRealtimeClientState(this);\n    if (state.status === \"open\") return __velarRealtimeResolved(state.generation);\n    if (state.status === \"closed\") return __velarRealtimeRejected(new RealtimeUnavailableError(\"Realtime client is closed\"));\n    if (state.openWaiters.length >= 256) return __velarRealtimeRejected(new RealtimeUnavailableError(\"Realtime open waiter limit exceeded\"));\n    return new __velarRealtimePromise((resolve, reject) => __velarRealtimeCall(__velarRealtimeArrayPush, state.openWaiters, [{resolve, reject}]));\n  },\n  async whenClosed() {\n    const state = __velarRealtimeClientState(this);\n    await state.done;\n    if (state.runnerFailure !== null) throw state.runnerFailure;\n    return null;\n  },\n  send(value) {\n    const state = __velarRealtimeClientState(this);\n    if (state.status !== \"open\" || state.connection === null) return __velarRealtimeRejected(new RealtimeUnavailableError());\n    let wire;\n    try { wire = __velarRealtimeCall(state.codec.encode, undefined, [value]); }\n    catch (failure) { return __velarRealtimeRejected(failure); }\n    return state.connection.send(wire);\n  },\n  async close(code = 1000, reason = \"\") {\n    const state = __velarRealtimeClientState(this);\n    if (state.status === \"closed\") return null;\n    if (!__velarRealtimeCall(__velarRealtimeNumberIsSafeInteger, Number, [code]) || code < 1000 || code > 4999) throw new RangeError(\"Realtime close code must be from 1000 through 4999\");\n    if (typeof reason !== \"string\" || __velarRealtimeUtf8Size(reason, 123) > 123) throw new RangeError(\"Realtime close reason cannot exceed 123 UTF-8 bytes\");\n    state.stopping = true;\n    if (state.delayWake !== null) state.delayWake();\n    if (state.connection !== null) await state.connection.close(code, reason);\n    if (state.runner !== null) await this.whenClosed();\n    else {\n      try { await __velarRealtimeTransition(this, \"closed\"); }\n      catch (failure) { state.runnerFailure = failure instanceof Error ? failure : new Error(\"Realtime state callback failed\"); }\n      __velarRealtimeRejectOpen(state, new RealtimeUnavailableError(\"Realtime client closed before opening\"));\n      state.resolveDone(null);\n      if (state.runnerFailure !== null) throw state.runnerFailure;\n    }\n    return null;\n  },\n});\n\nexport function realtimeClient(url, codec, receive, opened = null, failed = null, closed = null, stateChanged = null, options = {}) {\n  if (typeof url !== \"string\" && typeof url !== \"function\") throw new TypeError(\"realtimeClient URL must be text or a zero-argument function\");\n  codec = __velarRealtimeCodec(codec);\n  if (typeof receive !== \"function\") throw new TypeError(\"realtimeClient receive must be a function\");\n  opened = __velarRealtimeCallback(opened, \"realtimeClient opened\");\n  failed = __velarRealtimeCallback(failed, \"realtimeClient failed\");\n  closed = __velarRealtimeCallback(closed, \"realtimeClient closed\");\n  stateChanged = __velarRealtimeCallback(stateChanged, \"realtimeClient stateChanged\");\n  let resolveDone;\n  const done = new __velarRealtimePromise(resolve => { resolveDone = resolve; });\n  const client = Object.create(__velarRealtimeClientPrototype);\n  __velarRealtimeCall(__velarRealtimeWeakMapSet, __velarRealtimeClients, [client, {url, codec, receive, opened, failed, closed, stateChanged, options: __velarRealtimeOptions(options), status: \"idle\", generation: 0, connection: null, runner: null, runnerFailure: null, stopping: false, delayWake: null, openWaiters: [], done, resolveDone}]);\n  return __velarRealtimeFreeze(client);\n}\n\nconst __velarRealtimeClientType = __velarRealtimeFreeze({is(value) { return __velarRealtimeCall(__velarRealtimeWeakMapHas, __velarRealtimeClients, [value]); }, parse(value) { if (!this.is(value)) throw new TypeError(\"Value does not match RealtimeClient\"); return value; }});\nconst __velarRealtimeCodecType = __velarRealtimeFreeze({is(value) { try { __velarRealtimeCodec(value); return true; } catch { return false; } }, parse(value) { return __velarRealtimeCodec(value); }});\nconst __velarRealtimeFailureType = __velarRealtimeFreeze({is(value) { return value !== null && typeof value === \"object\" && typeof value.phase === \"string\" && value.error instanceof Error && typeof value.recoverable === \"boolean\"; }, parse(value) { if (!this.is(value)) throw new TypeError(\"Value does not match RealtimeFailure\"); return value; }});\nconst __velarRealtimeOpenType = __velarRealtimeFreeze({is(value) { return value !== null && typeof value === \"object\" && Number.isSafeInteger(value.generation) && typeof value.reconnected === \"boolean\"; }, parse(value) { if (!this.is(value)) throw new TypeError(\"Value does not match RealtimeOpen\"); return value; }});\n\nexport const RealtimeClient = __velarRealtimeFreeze({...__velarRealtimeClientType, of() { return __velarRealtimeClientType; }});\nexport const RealtimeCodec = __velarRealtimeFreeze({...__velarRealtimeCodecType, of() { return __velarRealtimeCodecType; }});\nexport const RealtimeFailure = __velarRealtimeFailureType;\nexport const RealtimeOpen = __velarRealtimeOpenType;\nexport const RealtimeClientState = __velarRealtimeFreeze({idle: \"idle\", connecting: \"connecting\", open: \"open\", reconnecting: \"reconnecting\", closed: \"closed\", is(value) { return value === \"idle\" || value === \"connecting\" || value === \"open\" || value === \"reconnecting\" || value === \"closed\"; }, parse(value) { if (!this.is(value)) throw new TypeError(\"Value does not match RealtimeClientState\"); return value; }, values() { return [\"idle\", \"connecting\", \"open\", \"reconnecting\", \"closed\"]; }});\nexport const RealtimeClientFailureAction = __velarRealtimeFreeze({continue: \"continue\", reconnect: \"reconnect\", stop: \"stop\", is(value) { return value === \"continue\" || value === \"reconnect\" || value === \"stop\"; }, parse(value) { if (!this.is(value)) throw new TypeError(\"Value does not match RealtimeClientFailureAction\"); return value; }, values() { return [\"continue\", \"reconnect\", \"stop\"]; }});\n";
/**
 * The one refusal `velar/browser` gives when there is no browser under it.
 *
 * D114 0.29.0 LC-I1: "there is no browser here" is one fact, and it used to
 * arrive in four sentences — two of them field validations ("Browser online
 * state must be bool") that sent the author to check his own data, and two
 * spellings of "The browser does not expose native …" that differed by a word.
 * `velar/storage` already answers this in one sentence at the call that needed
 * the host, and the charter's standard-library membership boundary requires the
 * failure to arrive there rather than at the import; this is that sentence for
 * `velar/browser`.
 *
 * The document is the host's own evidence: every guarded entry reads `window`,
 * `navigator`, `location` or the document itself, and none of the four exists
 * without it. With a document present, every entry behaves exactly as it did —
 * an argument is still checked before the host is touched, and a clipboard
 * outside a secure context still says so.
 */
export declare const WEB_BROWSER_REQUIRE_HOST_RUNTIME = "function __velarBrowserRequireHost(entry) {\n  const value = __velarBrowserDocument;\n  if (value === __velarBrowserMissingField || value === null || (typeof value !== \"object\" && typeof value !== \"function\")) {\n    throw new Error(\"velar/browser requires a browser host; \" + entry + \" was called where no document exists\");\n  }\n}\n";
export declare const WEB_FILE_REGISTRY_RUNTIME = "const nativeFilesKey = Symbol.for(\"velar.file.registry.v1\");\nconst nativeFiles = (() => {\n  const descriptor = Object.getOwnPropertyDescriptor(globalThis, nativeFilesKey);\n  if (descriptor) {\n    if (!(\"value\" in descriptor)) throw new TypeError(\"VelarScript file registry cannot be an accessor\");\n    if (descriptor.configurable || descriptor.enumerable || descriptor.writable) throw new TypeError(\"VelarScript file registry ownership is invalid\");\n    try { WeakMap.prototype.has.call(descriptor.value, descriptor.value); }\n    catch { throw new TypeError(\"VelarScript file registry is invalid\"); }\n    return descriptor.value;\n  }\n  const registry = new WeakMap();\n  Object.defineProperty(globalThis, nativeFilesKey, { value: registry, enumerable: false, configurable: false, writable: false });\n  return registry;\n})();\nconst __velarNativeFileName = typeof File === \"function\" ? Object.getOwnPropertyDescriptor(File.prototype, \"name\")?.get : null;\nconst __velarNativeFileModified = typeof File === \"function\" ? Object.getOwnPropertyDescriptor(File.prototype, \"lastModified\")?.get : null;\nconst __velarNativeBlobSize = typeof Blob === \"function\" ? Object.getOwnPropertyDescriptor(Blob.prototype, \"size\")?.get : null;\nconst __velarNativeBlobType = typeof Blob === \"function\" ? Object.getOwnPropertyDescriptor(Blob.prototype, \"type\")?.get : null;\nconst __velarNativeBlobText = typeof Blob === \"function\" ? Object.getOwnPropertyDescriptor(Blob.prototype, \"text\")?.value : null;\nfunction __velarReadNativeFileField(operation, file) {\n  if (typeof operation !== \"function\") throw new TypeError(\"The browser does not expose the required native File API\");\n  try { return operation.call(file); }\n  catch { throw new TypeError(\"A file picker returned an invalid native File\"); }\n}\nfunction __velarNativeFile(value, message) {\n  const file = value && WeakMap.prototype.get.call(nativeFiles, value);\n  if (!file) throw new TypeError(message);\n  try {\n    if (typeof __velarNativeFileName !== \"function\") throw new TypeError();\n    __velarNativeFileName.call(file);\n  } catch { throw new TypeError(message); }\n  return file;\n}\n";
export declare const WEB_LIST_GUARD_RUNTIME = "const __velarMaxListItems = 1000000;\nconst __velarListNativeArray = globalThis.Array;\nconst __velarListNativeObject = globalThis.Object;\nconst __velarListNativeSymbol = globalThis.Symbol;\nconst __velarListReflectApply = Object.getOwnPropertyDescriptor(Reflect, \"apply\")?.value;\nconst __velarListArrayIsArray = Object.getOwnPropertyDescriptor(Array, \"isArray\")?.value;\nconst __velarListGetOwnPropertySymbols = Object.getOwnPropertyDescriptor(Object, \"getOwnPropertySymbols\")?.value;\nconst __velarListGetOwnPropertyNames = Object.getOwnPropertyDescriptor(Object, \"getOwnPropertyNames\")?.value;\nconst __velarListGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor(Object, \"getOwnPropertyDescriptor\")?.value;\nconst __velarListDefineProperty = Object.getOwnPropertyDescriptor(Object, \"defineProperty\")?.value;\nconst __velarListSymbolFor = Object.getOwnPropertyDescriptor(Symbol, \"for\")?.value;\nconst __velarListRuntimeKey = typeof __velarListReflectApply === \"function\" && typeof __velarListSymbolFor === \"function\"\n  ? __velarListReflectApply(__velarListSymbolFor, __velarListNativeSymbol, [\"velar.runtime.v1\"]) : null;\nconst __velarListIterateKey = typeof __velarListReflectApply === \"function\" && typeof __velarListSymbolFor === \"function\"\n  ? __velarListReflectApply(__velarListSymbolFor, __velarListNativeSymbol, [\"velar.reactive.iterate.v1\"]) : null;\nfunction __velarRequireListIntrinsics() {\n  if (typeof __velarListNativeArray !== \"function\" || typeof __velarListNativeObject !== \"function\"\n    || typeof __velarListReflectApply !== \"function\" || typeof __velarListArrayIsArray !== \"function\"\n    || typeof __velarListGetOwnPropertySymbols !== \"function\" || typeof __velarListGetOwnPropertyNames !== \"function\"\n    || typeof __velarListGetOwnPropertyDescriptor !== \"function\" || typeof __velarListDefineProperty !== \"function\"\n    || __velarListRuntimeKey === null || __velarListIterateKey === null) {\n    throw new TypeError(\"The Web List guard intrinsics are unavailable\");\n  }\n}\nfunction __velarListReactiveRuntime() {\n  __velarRequireListIntrinsics();\n  const descriptor = __velarListReflectApply(__velarListGetOwnPropertyDescriptor, __velarListNativeObject, [globalThis, __velarListRuntimeKey]);\n  const runtime = descriptor && \"value\" in descriptor ? descriptor.value : null;\n  // No registry means no reactive runtime in this realm, which is ordinary Web\n  // behavior. A registry from another generation is a mixed build: reading past\n  // it would copy raw values and silently lose every collectionRead dependency,\n  // so it fails closed ahead of the callable duck-checks. The one installer\n  // that writes this slot always writes version, toRaw, collectionRead and\n  // report together, so this test is the same one Core, the JSON bridge and the\n  // Web foundation apply to the same slot \u2014 one tolerance rule per realm.\n  if (!runtime || (typeof runtime !== \"object\" && typeof runtime !== \"function\")) return null;\n  if (runtime.version !== \"0.12\") {\n    throw new TypeError(\"VelarScript reactive runtime schema \" + (typeof runtime.version === \"string\" ? runtime.version : \"(unknown)\") + \" does not match this module's schema 0.12; one build mixed two generations of @velarscript/* \u2014 run 'npm ls @velarscript/compiler' and pin one version\");\n  }\n  return typeof runtime.toRaw === \"function\" && typeof runtime.collectionRead === \"function\" ? runtime : null;\n}\nfunction __velarRequireList(value, name) {\n  __velarRequireListIntrinsics();\n  const reactive = __velarListReactiveRuntime();\n  if (reactive) value = reactive.toRaw(value);\n  if (!__velarListReflectApply(__velarListArrayIsArray, __velarListNativeArray, [value])) throw new TypeError(name + \" requires a List\");\n  if (value.length > __velarMaxListItems) throw new RangeError(name + \" cannot exceed \" + __velarMaxListItems + \" items\");\n  if (__velarListReflectApply(__velarListGetOwnPropertySymbols, __velarListNativeObject, [value]).length > 0\n    || __velarListReflectApply(__velarListGetOwnPropertyNames, __velarListNativeObject, [value]).length !== value.length + 1) {\n    throw new TypeError(name + \" requires a dense List without extra fields\");\n  }\n  const lengthDescriptor = __velarListReflectApply(__velarListGetOwnPropertyDescriptor, __velarListNativeObject, [value, \"length\"]);\n  if (!lengthDescriptor || !lengthDescriptor.writable || lengthDescriptor.enumerable\n    || lengthDescriptor.configurable || !(\"value\" in lengthDescriptor)) {\n    throw new TypeError(name + \" requires an ordinary mutable List length\");\n  }\n  const output = new __velarListNativeArray(value.length);\n  for (let index = 0; index < value.length; index += 1) {\n    const descriptor = __velarListReflectApply(__velarListGetOwnPropertyDescriptor, __velarListNativeObject, [value, index]);\n    if (!descriptor?.enumerable || !descriptor.configurable || !descriptor.writable || !(\"value\" in descriptor)) {\n      throw new TypeError(name + \" requires ordinary mutable List elements\");\n    }\n    const item = reactive ? reactive.collectionRead(value, __velarListIterateKey, descriptor.value) : descriptor.value;\n    __velarListReflectApply(__velarListDefineProperty, __velarListNativeObject, [output, index, {\n      value: item, enumerable: true, configurable: true, writable: true,\n    }]);\n  }\n  return output;\n}\n";
export declare const WEB_OPTIONS_GUARD_RUNTIME = "const __velarOptionsNativeArray = globalThis.Array;\nconst __velarOptionsNativeObject = globalThis.Object;\nconst __velarOptionsNativeSet = globalThis.Set;\nconst __velarOptionsReflectApply = Object.getOwnPropertyDescriptor(Reflect, \"apply\")?.value;\nconst __velarOptionsArrayIsArray = Object.getOwnPropertyDescriptor(Array, \"isArray\")?.value;\nconst __velarOptionsGetPrototypeOf = Object.getOwnPropertyDescriptor(Object, \"getPrototypeOf\")?.value;\nconst __velarOptionsGetOwnPropertySymbols = Object.getOwnPropertyDescriptor(Object, \"getOwnPropertySymbols\")?.value;\nconst __velarOptionsGetOwnPropertyNames = Object.getOwnPropertyDescriptor(Object, \"getOwnPropertyNames\")?.value;\nconst __velarOptionsGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor(Object, \"getOwnPropertyDescriptor\")?.value;\nconst __velarOptionsCreate = Object.getOwnPropertyDescriptor(Object, \"create\")?.value;\nconst __velarOptionsFreeze = Object.getOwnPropertyDescriptor(Object, \"freeze\")?.value;\nconst __velarOptionsSetHas = Object.getOwnPropertyDescriptor(Set.prototype, \"has\")?.value;\nconst __velarOptionsSetAdd = Object.getOwnPropertyDescriptor(Set.prototype, \"add\")?.value;\nconst __velarOptionsObjectPrototype = Object.prototype;\nfunction __velarRequireOptionsIntrinsics() {\n  if (typeof __velarOptionsNativeArray !== \"function\" || typeof __velarOptionsNativeObject !== \"function\"\n    || typeof __velarOptionsNativeSet !== \"function\" || typeof __velarOptionsReflectApply !== \"function\"\n    || typeof __velarOptionsArrayIsArray !== \"function\" || typeof __velarOptionsGetPrototypeOf !== \"function\"\n    || typeof __velarOptionsGetOwnPropertySymbols !== \"function\" || typeof __velarOptionsGetOwnPropertyNames !== \"function\"\n    || typeof __velarOptionsGetOwnPropertyDescriptor !== \"function\" || typeof __velarOptionsCreate !== \"function\"\n    || typeof __velarOptionsFreeze !== \"function\" || typeof __velarOptionsSetHas !== \"function\"\n    || typeof __velarOptionsSetAdd !== \"function\") {\n    throw new TypeError(\"The Web options guard intrinsics are unavailable\");\n  }\n}\nfunction __velarOptionFields(fields) {\n  __velarRequireOptionsIntrinsics();\n  if (!__velarOptionsReflectApply(__velarOptionsArrayIsArray, __velarOptionsNativeArray, [fields])) {\n    throw new TypeError(\"Web option fields must be an internal List\");\n  }\n  const allowed = new __velarOptionsNativeSet();\n  for (let index = 0; index < fields.length; index += 1) {\n    if (typeof fields[index] !== \"string\") throw new TypeError(\"Web option fields must be text\");\n    __velarOptionsReflectApply(__velarOptionsSetAdd, allowed, [fields[index]]);\n  }\n  return allowed;\n}\nfunction __velarFreezeOptionsValue(value) {\n  __velarRequireOptionsIntrinsics();\n  return __velarOptionsReflectApply(__velarOptionsFreeze, __velarOptionsNativeObject, [value]);\n}\nfunction __velarOptions(value, name, allowed) {\n  return __velarOptionsRecord(value, name, allowed, false);\n}\n// A live props store publishes every prop as a tracked getter, so the rule that\n// a field holds a data value cannot hold for it -- and the read through that\n// getter is exactly what subscribes the reader to the prop. Every other part of\n// the strict record rule still does: a plain record, no symbol fields, and no\n// field outside the declared set.\nfunction __velarLiveOptions(value, name, allowed) {\n  return __velarOptionsRecord(value, name, allowed, true);\n}\nfunction __velarOptionsRecord(value, name, allowed, live) {\n  __velarRequireOptionsIntrinsics();\n  let prototype = null;\n  if (value && typeof value === \"object\") {\n    prototype = __velarOptionsReflectApply(__velarOptionsGetPrototypeOf, __velarOptionsNativeObject, [value]);\n  }\n  if (!value || typeof value !== \"object\"\n    || __velarOptionsReflectApply(__velarOptionsArrayIsArray, __velarOptionsNativeArray, [value])\n    || (prototype !== __velarOptionsObjectPrototype && prototype !== null)) {\n    throw new TypeError(name + \" must be a record\");\n  }\n  if (__velarOptionsReflectApply(__velarOptionsGetOwnPropertySymbols, __velarOptionsNativeObject, [value]).length > 0) {\n    throw new TypeError(name + \" cannot contain symbol fields\");\n  }\n  const output = __velarOptionsReflectApply(__velarOptionsCreate, __velarOptionsNativeObject, [null]);\n  const keys = __velarOptionsReflectApply(__velarOptionsGetOwnPropertyNames, __velarOptionsNativeObject, [value]);\n  for (let index = 0; index < keys.length; index += 1) {\n    const key = keys[index];\n    if (!__velarOptionsReflectApply(__velarOptionsSetHas, allowed, [key])) throw new TypeError(\"Unknown \" + name + \" field '\" + key + \"'\");\n    const descriptor = __velarOptionsReflectApply(__velarOptionsGetOwnPropertyDescriptor, __velarOptionsNativeObject, [value, key]);\n    if (!descriptor?.enumerable || (!live && !(\"value\" in descriptor))) {\n      throw new TypeError(name + \" field '\" + key + \"' must be an enumerable \" + (live ? \"field\" : \"data value\"));\n    }\n    output[key] = \"value\" in descriptor ? descriptor.value : value[key];\n  }\n  return __velarFreezeOptionsValue(output);\n}\nfunction __velarString(value, name) { if (typeof value !== \"string\") throw new TypeError(name + \" must be a string\"); return value; }\nfunction __velarBool(value, name) { if (typeof value !== \"boolean\") throw new TypeError(name + \" must be bool\"); return value; }\n";
export declare const WEB_HOST_ABI_RUNTIME = "const __velarBrowserMissingField = Object.freeze({});\nconst __velarBrowserReflectApply = Object.getOwnPropertyDescriptor(Reflect, \"apply\")?.value;\nconst __velarBrowserGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor(Object, \"getOwnPropertyDescriptor\")?.value;\nconst __velarBrowserGetPrototypeOf = Object.getOwnPropertyDescriptor(Object, \"getPrototypeOf\")?.value;\nconst __velarBrowserHasInstance = Object.getOwnPropertyDescriptor(Function.prototype, Symbol.hasInstance)?.value;\nfunction __velarBrowserDescriptor(value, name) {\n  if ((typeof value !== \"object\" && typeof value !== \"function\") || value === null\n    || typeof __velarBrowserGetOwnPropertyDescriptor !== \"function\" || typeof __velarBrowserGetPrototypeOf !== \"function\") return null;\n  let current = value;\n  while (current !== null) {\n    const descriptor = __velarBrowserReflectApply(__velarBrowserGetOwnPropertyDescriptor, Object, [current, name]);\n    if (descriptor) return descriptor;\n    current = __velarBrowserReflectApply(__velarBrowserGetPrototypeOf, Object, [current]);\n  }\n  return null;\n}\nfunction __velarBrowserOwnDataField(value, name) {\n  if ((typeof value !== \"object\" && typeof value !== \"function\") || value === null\n    || typeof __velarBrowserGetOwnPropertyDescriptor !== \"function\") return __velarBrowserMissingField;\n  const descriptor = __velarBrowserReflectApply(__velarBrowserGetOwnPropertyDescriptor, Object, [value, name]);\n  return descriptor?.enumerable && \"value\" in descriptor ? descriptor.value : __velarBrowserMissingField;\n}\nfunction __velarBrowserDataMethod(value, name) {\n  const descriptor = __velarBrowserDescriptor(value, name);\n  return descriptor && \"value\" in descriptor && typeof descriptor.value === \"function\"\n    ? descriptor.value\n    : __velarBrowserMissingField;\n}\nfunction __velarBrowserGlobalMember(name, kind) {\n  const descriptor = __velarBrowserDescriptor(globalThis, name);\n  if (!descriptor) return null;\n  const member = kind === \"get\" ? descriptor.get : \"value\" in descriptor ? descriptor.value : null;\n  return typeof member === \"function\" ? member : null;\n}\nfunction __velarBrowserGlobalField(name) {\n  const descriptor = __velarBrowserDescriptor(globalThis, name);\n  if (!descriptor) return __velarBrowserMissingField;\n  if (\"value\" in descriptor) return descriptor.value;\n  if (typeof descriptor.get !== \"function\" || typeof __velarBrowserReflectApply !== \"function\") return __velarBrowserMissingField;\n  try { return __velarBrowserReflectApply(descriptor.get, globalThis, []); }\n  catch { return __velarBrowserMissingField; }\n}\nfunction __velarBrowserConstructor(name) {\n  const value = __velarBrowserGlobalField(name);\n  return typeof value === \"function\" ? value : null;\n}\nfunction __velarBrowserPrototypeMember(constructor, name, kind) {\n  if (typeof constructor !== \"function\" || typeof __velarBrowserGetOwnPropertyDescriptor !== \"function\") return null;\n  const descriptor = __velarBrowserReflectApply(__velarBrowserGetOwnPropertyDescriptor, Object, [constructor, \"prototype\"]);\n  const member = descriptor && \"value\" in descriptor ? __velarBrowserDescriptor(descriptor.value, name) : null;\n  if (!member) return null;\n  const operation = kind === \"get\" ? member.get : \"value\" in member ? member.value : null;\n  return typeof operation === \"function\" ? operation : null;\n}\nfunction __velarBrowserHostMember(value, constructor, name, kind) {\n  const descriptor = __velarBrowserDescriptor(value, name);\n  if (descriptor) {\n    const operation = kind === \"get\" ? descriptor.get : \"value\" in descriptor ? descriptor.value : null;\n    if (typeof operation === \"function\") return operation;\n  }\n  return __velarBrowserPrototypeMember(constructor, name, kind);\n}\nfunction __velarBrowserNativeInstance(value, constructor) {\n  if (typeof constructor !== \"function\" || typeof __velarBrowserHasInstance !== \"function\"\n    || typeof __velarBrowserReflectApply !== \"function\") return false;\n  try { return __velarBrowserReflectApply(__velarBrowserHasInstance, constructor, [value]) === true; }\n  catch { return false; }\n}\nfunction __velarBrowserField(value, name, nativeGetter, constructor) {\n  if (typeof nativeGetter === \"function\" && __velarBrowserNativeInstance(value, constructor)) {\n    return __velarBrowserReflectApply(nativeGetter, value, []);\n  }\n  return __velarBrowserOwnDataField(value, name);\n}\nfunction __velarBrowserCallCaptured(operation, receiver, arguments_, name) {\n  if (typeof operation !== \"function\" || typeof __velarBrowserReflectApply !== \"function\") {\n    throw new TypeError(\"The browser does not expose native \" + name);\n  }\n  return __velarBrowserReflectApply(operation, receiver, arguments_);\n}\nfunction __velarBrowserCall(value, name, nativeMethod, constructor, arguments_ = []) {\n  if (typeof nativeMethod === \"function\" && __velarBrowserNativeInstance(value, constructor)) {\n    return __velarBrowserReflectApply(nativeMethod, value, arguments_);\n  }\n  const method = __velarBrowserOwnDataField(value, name);\n  if (typeof method !== \"function\") throw new TypeError(\"The browser returned an invalid \" + name + \" host operation\");\n  return __velarBrowserCallCaptured(method, value, arguments_, name);\n}\n";
export declare const WEB_OWNED_CALLBACK_RUNTIME: string;
export declare const WEB_BROWSER_HOST_RUNTIME: string;
export declare const WEB_STORAGE_HOST_RUNTIME: string;
export declare const WEB_LOOK_MODULE: string;
export declare const WEB_APP_MODULE: string;
export declare const WEB_CONFIG_MODULE: string;
export declare const WEB_WEB_MODULE: string;
export declare const WEB_FORMS_MODULE: string;
export declare const WEB_HTTP_MODULE: string;
export declare const WEB_STORAGE_MODULE: string;
export declare const WEB_BROWSER_MODULE: string;
export declare const WEB_FILES_MODULE: string;
export declare const WEB_REALTIME_MODULE: string;
export declare const WEB_TEST_MODULE = "const browserRuntimeKey = Symbol.for(\"velar.browser.test.v1\");\nfunction browserRuntime() {\n  const runtime = globalThis[browserRuntimeKey];\n  if (!runtime) throw new Error(\"velar/web-test browser controls require 'velar test --browser'\");\n  return runtime;\n}\nexport const browser = Object.freeze({\n  open(path = \"/\") { return browserRuntime().open(path); },\n  reload() { return browserRuntime().reload(); },\n  click(selector) { return browserRuntime().click(selector); },\n  fill(selector, value) { return browserRuntime().fill(selector, value); },\n  select(selector, value) { return browserRuntime().select(selector, value); },\n  press(selector, key) { return browserRuntime().press(selector, key); },\n  scroll(selector, x, y) { return browserRuntime().scroll(selector, x, y); },\n  text(selector) { return browserRuntime().text(selector); },\n  attribute(selector, name) { return browserRuntime().attribute(selector, name); },\n  box(selector) { return browserRuntime().box(selector); },\n  style(selector, property) { return browserRuntime().style(selector, property); },\n  namespace(selector) { return browserRuntime().namespace(selector); },\n  count(selector) { return browserRuntime().count(selector); },\n  visible(selector) { return browserRuntime().visible(selector); },\n  waitFor(selector, state = \"visible\") { return browserRuntime().waitFor(selector, state); },\n  waitForText(selector, text) { return browserRuntime().waitForText(selector, text); },\n  currentPath() { return browserRuntime().currentPath(); },\n  viewport(width, height) { return browserRuntime().viewport(width, height); },\n  timings() { return browserRuntime().timings(); },\n  animation(selector) { return browserRuntime().animation(selector); },\n  measureClick(selector) { return browserRuntime().measureClick(selector); },\n  measureFill(selector, value) { return browserRuntime().measureFill(selector, value); },\n  measurePress(selector, key) { return browserRuntime().measurePress(selector, key); },\n});\nfunction storageRuntime(area) {\n  return Object.freeze({\n    get(key) { return browserRuntime().storageGet(area, key); },\n    set(key, value) { return browserRuntime().storageSet(area, key, value); },\n    remove(key) { return browserRuntime().storageRemove(area, key); },\n    clear() { return browserRuntime().storageClear(area); },\n  });\n}\nexport const localStorage = storageRuntime(\"local\");\nexport const sessionStorage = storageRuntime(\"session\");\nexport const network = Object.freeze({\n  respond(path, body, status = 200, contentType = \"application/json; charset=utf-8\", delayMs = 0) {\n    return browserRuntime().networkRespond(path, body, status, contentType, delayMs);\n  },\n  clear() { return browserRuntime().networkClear(); },\n});\n";
/** `is File` for a value the compiler could not prove, read through the registry's own descriptor. */
export declare const WEB_FILE_TYPE_RUNTIME = "function __velarFileTypeIs(value) {\n  const descriptor = Object.getOwnPropertyDescriptor(globalThis, Symbol.for(\"velar.file.registry.v1\"));\n  if (!descriptor || !(\"value\" in descriptor) || descriptor.configurable || descriptor.enumerable || descriptor.writable) return false;\n  try { return WeakMap.prototype.has.call(descriptor.value, value); }\n  catch { return false; }\n}\n";
export declare const WEB_LOCAL_REACTIVE_BRIDGE_RUNTIME = "const __velarReactiveRaw = __velarToRaw;\nfunction __velarHostRaw(value) { return __velarToRaw(value); }\n";
export declare const WEB_LOCAL_REACTIVE_COLLECTION_BRIDGE_RUNTIME = "const __velarReactiveIterateKey = Symbol.for(\"velar.reactive.iterate.v1\");\nconst __velarReactiveStructureKey = Symbol.for(\"velar.reactive.structure.v1\");\nconst __velarReactiveCollectionReadOperation = __velarRuntime.collectionRead;\nconst __velarReactiveCollectionTriggerOperation = __velarRuntime.collectionTrigger;\nconst __velarReactiveCollectionUnlinkOperation = __velarRuntime.collectionUnlink;\nconst __velarReactiveOperation = __velarRuntime.reactive;\nconst __velarReactiveTrackOperation = __velarRuntime.track;\nfunction __velarReactiveCollectionRead(value, key, child) { return __velarReactiveCollectionReadOperation(value, key, child === undefined ? null : child); }\nfunction __velarReactiveCollectionTrack(value, key = __velarReactiveIterateKey) { __velarReactiveTrackOperation(__velarToRaw(value), key); }\nfunction __velarReactiveCollectionLink(value, child) { __velarReactiveOperation(child, __velarToRaw(value)); }\nfunction __velarReactiveCollectionTrigger(value, key, iterate = true, structure = false, indexFrom = null, allKeys = false) { __velarReactiveCollectionTriggerOperation(value, key, iterate, structure, indexFrom, allKeys); }\nfunction __velarReactiveCollectionUnlink(value, child) { __velarReactiveCollectionUnlinkOperation(value, child); }\n";
/** Look unit arithmetic, for the modules whose `look:` values the compiler could not fold. */
export declare const LOOK_ARITHMETIC_RUNTIME = "function __velarLookDimension(value) {\n  if (typeof value !== \"string\") return null;\n  const match = /^([+-]?(?:\\d+(?:\\.\\d+)?|\\.\\d+))(px|rem|em|vw|vh|vmin|vmax|%|fr|ms|s|deg|turn)$/.exec(value);\n  if (!match) return null;\n  const number = Number(match[1]);\n  return Number.isFinite(number) ? { number, unit: match[2] } : null;\n}\n\nfunction __velarLookNumber(value, label) {\n  if (typeof value !== \"number\" || !Number.isFinite(value)) throw new TypeError(label + \" must be a finite number\");\n  return value;\n}\n\nfunction __velarLookDimensionResult(number, unit) {\n  if (!Number.isFinite(number)) throw new RangeError(\"Look arithmetic must produce a finite value\");\n  return String(Object.is(number, -0) ? 0 : number) + unit;\n}\n\nfunction __velarLookConvertibleDimension(value) {\n  if (value.unit === \"s\") return { number: value.number * 1000, unit: \"ms\" };\n  if (value.unit === \"turn\") return { number: value.number * 360, unit: \"deg\" };\n  return value;\n}\n\nfunction __velarLookUnary(operator, value) {\n  if (typeof value === \"number\") return operator === \"-\" ? -__velarLookNumber(value, \"Look operand\") : __velarLookNumber(value, \"Look operand\");\n  if (typeof value !== \"string\") throw new TypeError(\"Look unit arithmetic requires a number or typed visual value\");\n  if (operator === \"+\") return value;\n  const dimension = __velarLookDimension(value);\n  if (dimension) return __velarLookDimensionResult(-dimension.number, dimension.unit);\n  return \"calc(-1 * (\" + value + \"))\";\n}\n\nfunction __velarLookMath(operator, left, right) {\n  if (typeof left === \"number\" && typeof right === \"number\") {\n    const first = __velarLookNumber(left, \"Left Look operand\");\n    const second = __velarLookNumber(right, \"Right Look operand\");\n    if (operator === \"/\" && second === 0) throw new RangeError(\"Look division cannot use zero\");\n    const result = operator === \"+\" ? first + second : operator === \"-\" ? first - second : operator === \"*\" ? first * second : first / second;\n    return __velarLookNumber(result, \"Look arithmetic result\");\n  }\n  const leftDimension = __velarLookDimension(left);\n  const rightDimension = __velarLookDimension(right);\n  if ((operator === \"+\" || operator === \"-\") && leftDimension && rightDimension) {\n    const first = __velarLookConvertibleDimension(leftDimension);\n    const second = __velarLookConvertibleDimension(rightDimension);\n    if (first.unit === second.unit) {\n      return __velarLookDimensionResult(operator === \"+\" ? first.number + second.number : first.number - second.number, first.unit);\n    }\n  }\n  if (operator === \"*\" && leftDimension && typeof right === \"number\") {\n    return __velarLookDimensionResult(leftDimension.number * __velarLookNumber(right, \"Right Look operand\"), leftDimension.unit);\n  }\n  if (operator === \"*\" && typeof left === \"number\" && rightDimension) {\n    return __velarLookDimensionResult(__velarLookNumber(left, \"Left Look operand\") * rightDimension.number, rightDimension.unit);\n  }\n  if (operator === \"/\" && leftDimension && typeof right === \"number\") {\n    const divisor = __velarLookNumber(right, \"Right Look operand\");\n    if (divisor === 0) throw new RangeError(\"Look unit division cannot use zero\");\n    return __velarLookDimensionResult(leftDimension.number / divisor, leftDimension.unit);\n  }\n  if ((typeof left !== \"string\" && typeof left !== \"number\") || (typeof right !== \"string\" && typeof right !== \"number\")) {\n    throw new TypeError(\"Look unit arithmetic requires numbers or typed visual values\");\n  }\n  return \"calc(\" + left + \" \" + operator + \" \" + right + \")\";\n}\n";
/**
 * The Web runtime an emitted program carries inside itself: reporting,
 * observers and cells, managed async, component scopes, the DOM writer, and
 * the look/class/style appliers. `webRuntime` splices the module's own
 * keyword table into it; everything else here is the same for every program.
 */
export declare const WEB_RUNTIME_BODY: string;
//# sourceMappingURL=runtime-sources.generated.d.ts.map