@velarscript/web 0.31.0 → 0.32.0

package/dist/compiler.js

@@ -1,892 +1,57 @@
-import { optionalOf as optional } from "@velarscript/compiler";
-import { inferWebIntrinsic, routeContextIdentity, VelarWebAnalyzer } from "./analyzer.js";
-import { WEB_STATEMENT_CONSTRUCTS, webExpressionContainsDirectAwait, isWebJsx, webStatementConstructKey, webStatementContainsDirectAwait, } from "./ast.js";
+/**
+ * The Web extension's composition root. `compiler.ts` was one 1,136-line module;
+ * D115 P4 R3e moved each `velar/*` surface's `ValueType` tables into its own
+ * `modules/<surface>.ts` file and the editor prose into `documentation.ts`, and
+ * left here what a composition root is: the published surface version, the
+ * assembled module map, and the frozen extension literal every part of the
+ * toolchain reads the Web target through.
+ *
+ * Where to look:
+ *
+ *  - `modules/types.ts`     the type vocabulary every surface table is written in
+ *  - `modules/<surface>.ts` one file per `velar/*` surface, holding its tables and its entry
+ *  - `module-roster.ts`     the ordered entry list this file assembles the map from
+ *  - `documentation.ts`     the three editor-documentation tables
+ */
+import {} from "@velarscript/compiler";
+import { inferWebIntrinsic, VelarWebAnalyzer } from "./analyzer.js";
+import { WEB_STATEMENT_CONSTRUCTS, webExpressionContainsDirectAwait, webStatementConstructKey, webStatementContainsDirectAwait, } from "./ast.js";
 import { BROWSER_TEST_MODULE, BROWSER_TEST_SOURCE_SUFFIX, browserTestDrivingGuidance } from "./browser-test.js";
-import { WEB_NATIVE_ELEMENTS, WEB_VOID_ELEMENTS } from "./elements.js";
+import { webKeywordDocumentation } from "./documentation.js";
+import { WEB_VOID_ELEMENTS } from "./elements.js";
 import { WebJavaScriptEmitter } from "./emitter.js";
-import { velarWebProjectEditorExtension, webLookPropertyDocumentation } from "./editor.js";
+import { velarWebProjectEditorExtension } from "./editor.js";
 import { velarWebInspectionExtension } from "./inspection.js";
+import { webModuleEntries } from "./module-roster.js";
+import { mountTargetType, namedFunction, nodeType, nullType, webCanonicalCollectionProjection } from "./modules/types.js";
 import { VelarWebParser } from "./parser.js";
 import { scanWebToken, scanWebUnsafeCssLiteral, WEB_CONTEXTUAL_KEYWORDS } from "./lexer.js";
 import { webModuleSource, webModuleSources } from "./runtime.js";
 import { velarWebSemanticExtension } from "./semantic.js";
-import { LOOK_BUILDER_SIGNATURES, LOOK_BUILDERS, LOOK_HOOKS, LOOK_MEDIA_SUBJECTS, LOOK_PUBLIC_TYPE_NAMES, LOOK_TARGETS, LOOK_UNIT_TYPES } from "./look.js";
-import { isWebTypeAssignable, resolveWebTypeSyntax, WEB_OWNED_TYPE_NAMES, webComponentConstructor, webLengthPercentageInput, webNodeType } from "./types.js";
+import { LOOK_BUILDERS, LOOK_MEDIA_SUBJECTS, LOOK_UNIT_TYPES } from "./look.js";
+import { isWebTypeAssignable, resolveWebTypeSyntax, WEB_OWNED_TYPE_NAMES } from "./types.js";
 export const VELAR_WEB_API_VERSION = "0.14";
-const bytesType = { kind: "named", name: "Bytes", identity: "velar/binary#type:Bytes" };
 // D57 rule 138 gave the browser-test boundary teeth, so the two names it is
 // written in are part of the published contract: the framework host hands the
 // suffix to the CLI runner, and tooling that has to name a browser test module
 // reads both from here instead of spelling them again.
 export { BROWSER_TEST_MODULE, BROWSER_TEST_SOURCE_SUFFIX } from "./browser-test.js";
-const nullType = { kind: "null" };
-const stringType = { kind: "string" };
-const numberType = { kind: "number" };
-const boolType = { kind: "bool" };
-const nodeType = webNodeType;
-const elementType = { kind: "named", name: "Element" };
-const inputElementType = { kind: "named", name: "InputElement" };
-const textAreaElementType = { kind: "named", name: "TextAreaElement" };
-const canvasElementType = { kind: "named", name: "CanvasElement" };
-const dialogElementType = { kind: "named", name: "DialogElement" };
-const blobType = { kind: "named", name: "Blob" };
-const lengthType = { kind: "named", name: "Length" };
-const percentageType = { kind: "named", name: "Percentage" };
-const lengthPercentageType = { kind: "named", name: "LengthPercentage" };
-const trackFractionType = { kind: "named", name: "TrackFraction" };
-const colorType = { kind: "named", name: "Color" };
-const colorInputType = colorType;
-const borderType = { kind: "named", name: "Border" };
-const shadowType = { kind: "named", name: "Shadow" };
-const filterType = { kind: "named", name: "Filter" };
-const imageType = { kind: "named", name: "Image" };
-const trackType = { kind: "named", name: "Track" };
-const trackListType = { kind: "named", name: "TrackList" };
-/**
- * Native JSX construction preserves the order and count of a collection
- * projection. Attribute and child holes still have to pass Core's stability
- * proof; event arrows are inert values here and run only after dispatch.
- * Components, custom elements, refs, and bindings keep the explicit loop
- * because their setup can execute user code or write through a binding.
- */
-function webCanonicalCollectionProjection(expression, pure) {
-    if (!isWebJsx(expression))
-        return undefined;
-    if (expression.tag !== "" && !WEB_NATIVE_ELEMENTS.has(expression.tag))
-        return false;
-    for (const attribute of expression.attributes) {
-        if (attribute.name === "ref" || attribute.name.startsWith("bind:"))
-            return false;
-        if (typeof attribute.value === "string" || attribute.value === null)
-            continue;
-        if (attribute.name.startsWith("on:") && attribute.value.kind === "ArrowFunctionExpression")
-            continue;
-        if (!pure(attribute.value))
-            return false;
-    }
-    for (const child of expression.children) {
-        if (child.kind === "JSXText")
-            continue;
-        if (child.kind === "ExtensionExpression:web:jsx") {
-            if (webCanonicalCollectionProjection(child, pure) !== true)
-                return false;
-            continue;
-        }
-        if (!pure(child.expression))
-            return false;
-    }
-    return true;
-}
-const transitionType = { kind: "named", name: "Transition" };
-const keyframesType = { kind: "named", name: "Keyframes" };
-const animationType = { kind: "named", name: "Animation" };
-const durationType = { kind: "named", name: "Duration" };
-const angleType = { kind: "named", name: "Angle" };
-const spacingType = { kind: "named", name: "Spacing" };
-const mountTargetType = { kind: "union", members: [stringType, elementType] };
-const lookScalarType = { kind: "union", members: [numberType, stringType, lengthType, percentageType, lengthPercentageType] };
-const trackInputType = { kind: "union", members: [numberType, stringType, lengthType, percentageType, lengthPercentageType, trackFractionType, trackType, trackListType] };
-const repeatCountType = { kind: "union", members: [numberType, stringType] };
-const lookBuilderResultTypes = {
-    animation: animationType,
-    border: borderType,
-    color: colorType,
-    filter: filterType,
-    image: imageType,
-    length: lengthType, "length-percentage": lengthPercentageType,
-    shadow: shadowType,
-    spacing: spacingType,
-    string: stringType,
-    track: trackType,
-    "track-list": trackListType,
-    transition: transitionType,
-};
-function namedFunction(parameterNames, parameters, result, requiredParameters = parameters.length) {
-    return { kind: "function", parameterNames, parameters, requiredParameters, result };
-}
-/**
- * A velar/look builder's published type, with its parameter names and required
- * count read from LOOK_BUILDER_SIGNATURES rather than repeated here. The static
- * keyframe lowering places named arguments from that same table, so the two
- * cannot disagree about what `spread=0px` means.
- */
-function lookBuilder(name, parameters, rest) {
-    const signature = LOOK_BUILDER_SIGNATURES.get(name);
-    if (!signature)
-        throw new Error(`velar/look builder '${name}' has no declared signature`);
-    if (signature.parameters.length !== parameters.length) {
-        throw new Error(`velar/look builder '${name}' declares ${signature.parameters.length} parameters but types ${parameters.length}`);
-    }
-    if ((signature.rest ?? false) !== (rest !== undefined)) {
-        throw new Error(`velar/look builder '${name}' disagrees with its declared rest parameter`);
-    }
-    return {
-        kind: "function",
-        parameterNames: signature.parameters,
-        parameters,
-        requiredParameters: signature.required,
-        ...(rest ? { rest } : {}),
-        result: lookBuilderResultTypes[signature.result],
-    };
-}
-const unknownType = { kind: "unknown" };
 const webGlobals = new Map([
     ["mount", namedFunction(["node", "target"], [nodeType, mountTargetType], nullType)],
     ["tick", namedFunction([], [], { kind: "promise", value: nullType })],
 ]);
-const lookModuleExports = new Map([
-    ...LOOK_PUBLIC_TYPE_NAMES.map((name) => [name, { kind: "typeObject", name, value: { kind: "named", name } }]),
-    // D103: a token reference has no visual kind of its own, because the design
-    // system owns the value and the compiler cannot see it. `string` is the type
-    // every checked Look property kind already admits alongside its own visual
-    // type, which is what makes one spelling legal in all of them; the kinds keep
-    // their D37 keyword tables, which read literals and folded keywords and so
-    // never see a call.
-    ["token", lookBuilder("token", [stringType])],
-    ["color", lookBuilder("color", [stringType])],
-    ["rgb", lookBuilder("rgb", [numberType, numberType, numberType])],
-    ["rgba", lookBuilder("rgba", [numberType, numberType, numberType, numberType])],
-    ["hsl", lookBuilder("hsl", [numberType, percentageType, percentageType])], // LK-I3: CSS spells those two slots as percentages and so does this language.
-    ["alpha", lookBuilder("alpha", [colorInputType, numberType])],
-    ["lighten", lookBuilder("lighten", [colorInputType, numberType])],
-    ["darken", lookBuilder("darken", [colorInputType, numberType])],
-    ["border", lookBuilder("border", [lengthType, colorInputType, stringType])],
-    ["shadow", lookBuilder("shadow", [lengthType, lengthType, lengthType, colorInputType, lengthType, boolType])],
-    ["blur", lookBuilder("blur", [lengthType])],
-    ["brightness", lookBuilder("brightness", [numberType])],
-    ["contrast", lookBuilder("contrast", [numberType])],
-    ["dropShadow", lookBuilder("dropShadow", [lengthType, lengthType, lengthType, colorInputType])],
-    ["grayscale", lookBuilder("grayscale", [numberType])],
-    ["hueRotate", lookBuilder("hueRotate", [angleType])],
-    ["invert", lookBuilder("invert", [numberType])],
-    ["filterOpacity", lookBuilder("filterOpacity", [numberType])],
-    ["saturate", lookBuilder("saturate", [numberType])],
-    ["sepia", lookBuilder("sepia", [numberType])],
-    ["filters", lookBuilder("filters", [filterType], filterType)],
-    ["linearGradient", lookBuilder("linearGradient", [angleType, colorInputType, colorInputType])],
-    ["asset", lookBuilder("asset", [stringType])],
-    ["minmax", lookBuilder("minmax", [trackInputType, trackInputType])],
-    ["repeat", lookBuilder("repeat", [repeatCountType, trackInputType])],
-    ["tracks", lookBuilder("tracks", [trackInputType], trackInputType)],
-    ["transition", lookBuilder("transition", [stringType, durationType, stringType, durationType])],
-    ["spacing", lookBuilder("spacing", [lookScalarType, lookScalarType, lookScalarType, lookScalarType])],
-    ["min", lookBuilder("min", [webLengthPercentageInput, webLengthPercentageInput])],
-    ["max", lookBuilder("max", [webLengthPercentageInput, webLengthPercentageInput])],
-    ["clamp", lookBuilder("clamp", [webLengthPercentageInput, webLengthPercentageInput, webLengthPercentageInput])],
-    ["animate", lookBuilder("animate", [keyframesType, durationType, stringType, durationType, numberType, boolType, stringType, stringType])],
-]);
-// D52 rule 114: `Look.` is gone. JavaScript has no `Look` global, so the
-// prefix was ours to invent and ours to withdraw — and a look block is the
-// densest run of calls in the language, which is the worst place to spend four
-// characters per call on a word that adds nothing. The builders are named
-// imports again; `Look` survives only as the type of a look value.
 const webTextFormTypes = new Set(LOOK_UNIT_TYPES.values());
 // D72 rule 186: derived from the one published table. `Component` is the only
 // name that answers `textForm` differently — it is a constructor contract
 // rather than a value type — so it is subtracted here rather than kept in a
 // second list.
 const webOwnedNamedTypes = new Set([...WEB_OWNED_TYPE_NAMES].filter((name) => name !== "Component"));
-function functionType(parameters, result, requiredParameters = parameters.length) {
-    return { kind: "function", parameters, requiredParameters, result };
-}
-function namedIntrinsic(name, parameterNames, parameters, result, requiredParameters = parameters.length) {
-    return { kind: "intrinsic", name, parameterNames, parameters, requiredParameters, result };
-}
-function promise(value) {
-    return { kind: "promise", value };
-}
-function object(fields) {
-    return { kind: "object", fields: new Map(Object.entries(fields)) };
-}
-/** A structurally declared standard capability handle; see ValueType.capabilityHandle. */
-function capabilityHandle(fields) {
-    return { kind: "object", fields: new Map(Object.entries(fields)), capabilityHandle: true };
-}
-const errorType = { kind: "class", name: "Error" };
-const cleanupType = namedFunction([], [], nullType);
-const arrayString = { kind: "list", element: stringType };
-const arrayNumber = { kind: "list", element: numberType };
-const mapString = (value) => ({ kind: "map", key: stringType, value });
-const webElementType = { kind: "union", members: [elementType, inputElementType, canvasElementType, dialogElementType] };
-const fileType = { kind: "named", name: "File" };
-const fileArrayType = { kind: "list", element: fileType };
-const formBodyType = object({
-    field: namedFunction(["name", "value"], [stringType, stringType], nullType),
-    file: namedFunction(["name", "value", "fileName"], [stringType, fileType, stringType], nullType, 2),
-    files: namedFunction(["name", "values"], [stringType, fileArrayType], nullType),
-    remove: namedFunction(["name"], [stringType], nullType),
-    has: namedFunction(["name"], [stringType], boolType),
-    names: namedFunction([], [], arrayString),
-});
-const httpChunkConsumerType = namedFunction(["chunk"], [stringType], promise(nullType));
-const httpTransportPhaseIdentity = "velar/http#enum:HttpTransportPhase";
-const httpTransportPhaseMembers = new Set(["request", "response"]);
-const httpTransportPhaseWireValues = new Map([...httpTransportPhaseMembers].map((member) => [member, member]));
-const httpTransportPhaseType = { kind: "enum", name: "HttpTransportPhase", identity: httpTransportPhaseIdentity };
-const httpTransportErrorIdentity = "velar/http#class:HttpTransportError";
-// D90 R20: `ok` is gone from the response. `response()` throws
-// `HttpResponseError` for every non-2xx, so the only response an author can
-// hold has `ok === true` — a field that is always true is a lie in the type,
-// and `if not r.ok:` was a dead branch the tour taught twice. The failure
-// path is a `catch` that narrows with `is HttpResponseError`, and the
-// analyzer says so when the old field is read.
-const httpResponseType = object({
-    status: numberType,
-    statusText: stringType,
-    url: stringType,
-    headers: mapString(stringType),
-    json: namedFunction([], [], promise(unknownType)),
-    text: namedFunction([], [], promise(stringType)),
-    bytes: namedFunction([], [], promise(bytesType)),
-    streamText: namedFunction(["consume"], [httpChunkConsumerType], promise(nullType)),
-    blob: namedFunction([], [], promise(blobType)),
-    parse: namedIntrinsic("runtime.parseAsync", ["target"], [unknownType], promise(unknownType)),
-});
-const requestType = object({
-    response: namedFunction([], [], promise(httpResponseType)),
-    json: namedFunction([], [], promise(unknownType)),
-    text: namedFunction([], [], promise(stringType)),
-    bytes: namedFunction([], [], promise(bytesType)),
-    streamText: namedFunction(["consume"], [httpChunkConsumerType], promise(nullType)),
-    blob: namedFunction([], [], promise(blobType)),
-    parse: namedIntrinsic("runtime.parseAsync", ["target"], [unknownType], promise(unknownType)),
-    cancel: namedFunction([], [], nullType),
-});
-const httpOptionsType = object({
-    headers: optional(mapString(stringType)),
-    body: optional(unknownType),
-    timeout: optional(numberType),
-    maxBytes: optional(numberType),
-    credentials: optional(stringType),
-    cache: optional(stringType),
-});
-const httpType = object({
-    request: namedIntrinsic("http.request", ["method", "url", "options"], [stringType, stringType, httpOptionsType], requestType, 2),
-    get: namedIntrinsic("http.request", ["url", "options"], [stringType, httpOptionsType], requestType, 1),
-    post: namedIntrinsic("http.request", ["url", "options"], [stringType, httpOptionsType], requestType, 1),
-    put: namedIntrinsic("http.request", ["url", "options"], [stringType, httpOptionsType], requestType, 1),
-    patch: namedIntrinsic("http.request", ["url", "options"], [stringType, httpOptionsType], requestType, 1),
-    delete: namedIntrinsic("http.request", ["url", "options"], [stringType, httpOptionsType], requestType, 1),
-    head: namedIntrinsic("http.request", ["url", "options"], [stringType, httpOptionsType], requestType, 1),
-});
-function createStorageType() {
-    const common = () => new Map([
-        ["get", namedIntrinsic("storage.get", ["key", "target", "fallback", "maxBytes"], [stringType, unknownType, unknownType, numberType], unknownType, 2)],
-        ["set", namedIntrinsic("storage.set", ["key", "value", "maxBytes"], [stringType, unknownType, numberType], nullType, 2)],
-        ["has", namedFunction(["key"], [stringType], boolType)],
-        ["keys", namedFunction([], [], arrayString)],
-        ["remove", namedFunction(["key"], [stringType], nullType)],
-        ["clear", namedFunction([], [], nullType)],
-        ["watch", namedIntrinsic("storage.watch", ["key", "target", "callback", "maxBytes"], [stringType, unknownType, unknownType, numberType], cleanupType, 3)],
-    ]);
-    const scoped = { kind: "object", fields: common() };
-    const fields = common();
-    fields.set("scope", namedFunction(["name"], [stringType], scoped));
-    return { kind: "object", fields };
-}
-const storageType = createStorageType();
-const storageBatchChangeType = object({ key: stringType, bytes: optional(bytesType) });
-const databaseType = object({
-    get: namedIntrinsic("storage.databaseGet", ["key", "target", "fallback", "maxBytes"], [stringType, unknownType, unknownType, numberType], promise(unknownType), 2),
-    set: namedIntrinsic("storage.set", ["key", "value", "maxBytes"], [stringType, unknownType, numberType], promise(nullType), 2),
-    getBytes: namedFunction(["key", "fallback", "maxBytes"], [stringType, optional(bytesType), numberType], promise(optional(bytesType)), 1),
-    setBytes: namedFunction(["key", "value", "maxBytes"], [stringType, bytesType, numberType], promise(nullType), 2),
-    batch: namedFunction(["changes"], [{ kind: "list", element: storageBatchChangeType }], promise(nullType)),
-    has: namedFunction(["key"], [stringType], promise(boolType)),
-    keys: namedFunction([], [], promise(arrayString)),
-    remove: namedFunction(["key"], [stringType], promise(nullType)),
-    clear: namedFunction([], [], promise(nullType)),
-});
-const storageQuotaErrorIdentity = "velar/storage#class:StorageQuotaError";
-const storageTransactionErrorIdentity = "velar/storage#class:StorageTransactionError";
-const storageUpgradeErrorIdentity = "velar/storage#class:StorageUpgradeError";
-function storageErrorClass(identity) {
-    return {
-        identity, parameters: [stringType], parameterNames: ["message"], requiredParameters: 0,
-        base: "Error", abstract: false, fields: new Map(), getters: new Set(), abstractGetters: new Set(),
-        methods: new Map(), abstractMethods: new Set(), staticFields: new Map(), staticGetters: new Set(), staticMethods: new Map(),
-    };
-}
 /**
- * D90 R17-a left exactly one `any` standing in this file, and this is it.
- *
- * `component` holds a component constructor, not a rendered node, so
- * `webNodeType` is the wrong family — the two referees that check this slot
- * (`checkRouteComponent` and `checkWebRouteComponent`) match it with
- * `isWebComponentType`, and `isWebTypeAssignable` refuses a component against a
- * node outright. `unknown`, the answer R17 gives every other boundary position
- * here, is refused by the shape of assignability rather than by the ruling: a
- * writable object field and a List element are both compared *invariantly*, and
- * `unknown` is invariant with nothing, so `List<{path, component: Page}>` — the
- * type a route list bound to a name actually has — would stop being assignable
- * to the Router's `routes` prop. `any` is the only spelling that is invariant
- * with every component type at once, and no published name means "some
- * component"; R17-a declined to mint one. The slot is checked by its two
- * referees, not by this declaration.
+ * The `velar/*` surfaces this capability publishes. One `modules/<surface>.ts`
+ * file owns each entry's tables; `module-roster.ts` owns the order they are
+ * assembled in, because a file this map is built from cannot import the map.
  */
-const routeComponentType = { kind: "any" };
-const routeType = object({
-    path: stringType,
-    component: routeComponentType,
-});
-const routeContextFields = new Map([
-    ["path", stringType],
-    ["params", mapString(stringType)],
-    ["query", mapString(stringType)],
-    ["hash", stringType],
-]);
-const routeContextType = { kind: "named", name: "RouteContext", identity: routeContextIdentity };
-const navigationOptionsType = object({ replace: optional(boolType), scroll: optional(boolType) });
-const formValuesType = { kind: "map", key: stringType, value: unknownType };
-const browserLocationType = object({
-    href: stringType,
-    origin: stringType,
-    path: stringType,
-    query: mapString(stringType),
-    hash: stringType,
-});
-const browserEnvironmentType = object({
-    language: stringType,
-    languages: arrayString,
-    online: boolType,
-    visible: boolType,
-    colorScheme: stringType,
-    reducedMotion: boolType,
-    touch: boolType,
-});
-const rectType = object({
-    x: numberType, y: numberType, width: numberType, height: numberType,
-    top: numberType, right: numberType, bottom: numberType, left: numberType,
-});
-const scrollMetricsType = object({
-    x: numberType, y: numberType,
-    viewportWidth: numberType, viewportHeight: numberType,
-    contentWidth: numberType, contentHeight: numberType,
-});
-// P2a-4 — `watchIntersection` completes the `velar/browser` watcher family for
-// the one question the family could not answer: has *this element* entered or
-// left the viewport. The family's shape is kept exactly — a callback plus a
-// `() -> null` cleanup, never a live host object — and the entry carries the
-// two fields the platform actually guarantees for a single observed target.
-// `time` and the four rectangles are deliberately absent: a rectangle read from
-// an observer entry is a layout snapshot from the *observation* moment rather
-// than from now, so publishing it would invite exactly the read-a-stale-box
-// mistake `measure` exists to avoid.
-//
-// The configuration is closed rather than an options passthrough: a `root` that
-// scopes the observation to a scroll container, and a bounded threshold list.
-// `rootMargin` is not in it — it is a CSS-string dialect parsed by the host,
-// which is the one thing a checked surface must not accept as a string.
-const intersectionEntryType = object({ intersecting: boolType, ratio: numberType });
-const intersectionOptionsType = object({ root: optional(webElementType), thresholds: optional(arrayNumber) });
-const textSelectionType = object({ start: numberType, end: numberType, direction: stringType });
-const fileOptionsType = object({ accept: optional(stringType), multiple: optional(boolType) });
-// D51 (audit 12): the realtime handle is a standard capability handle that
-// publishes `close()`, so `using` supplies its release contract (charter
-// section 16). It is declared structurally rather than as a named type, and
-// the marker is what lets Core see it without ever detecting a shape.
-//
-// `velar/websocket.connect` remains the sole raw WebSocket transport. The
-// higher-level `realtimeClient` below composes it with typed codecs, lifecycle,
-// and reconnect policy; it does not duplicate framing or invent a second
-// socket contract.
-const eventStreamHandlersType = object({
-    open: optional(functionType([], unknownType)),
-    message: optional(functionType([stringType, stringType], unknownType)),
-    error: optional(functionType([stringType], unknownType)),
-});
-const eventStreamType = capabilityHandle({ url: stringType, state: namedFunction([], [], stringType), close: namedFunction([], [], nullType) });
-const appErrorType = object({
-    error: errorType,
-    phase: stringType,
-    detail: stringType,
-    component: stringType,
-    timestamp: numberType,
-});
-const browserTestNavigationTimingType = object({
-    firstContentfulPaintMs: optional(numberType),
-    domContentLoadedMs: numberType,
-    loadMs: numberType,
-});
-const browserTestInteractionTimingType = object({
-    inputDelayMs: numberType,
-    processingDurationMs: numberType,
-    nextFrameMs: numberType,
-});
-const browserTestAnimationType = object({
-    count: numberType,
-    name: stringType,
-    rotating: boolType,
-});
-const browserTestControllerType = object({
-    open: namedFunction(["path"], [stringType], promise(nullType), 0),
-    reload: namedFunction([], [], promise(nullType)),
-    click: namedFunction(["selector"], [stringType], promise(nullType)),
-    fill: namedFunction(["selector", "value"], [stringType, stringType], promise(nullType)),
-    select: namedFunction(["selector", "value"], [stringType, stringType], promise(nullType)),
-    press: namedFunction(["selector", "key"], [stringType, stringType], promise(nullType)),
-    scroll: namedFunction(["selector", "x", "y"], [stringType, numberType, numberType], promise(nullType)),
-    text: namedFunction(["selector"], [stringType], promise(stringType)),
-    attribute: namedFunction(["selector", "name"], [stringType, stringType], promise(optional(stringType))),
-    box: namedFunction(["selector"], [stringType], promise(rectType)),
-    style: namedFunction(["selector", "property"], [stringType, stringType], promise(stringType)),
-    namespace: namedFunction(["selector"], [stringType], promise(stringType)),
-    count: namedFunction(["selector"], [stringType], promise(numberType)),
-    visible: namedFunction(["selector"], [stringType], promise(boolType)),
-    waitFor: namedFunction(["selector", "until"], [stringType, stringType], promise(nullType), 1),
-    waitForText: namedFunction(["selector", "text"], [stringType, stringType], promise(nullType)),
-    currentPath: namedFunction([], [], promise(stringType)),
-    viewport: namedFunction(["width", "height"], [numberType, numberType], promise(nullType)),
-    timings: namedFunction([], [], promise(browserTestNavigationTimingType)),
-    animation: namedFunction(["selector"], [stringType], promise(browserTestAnimationType)),
-    measureClick: namedFunction(["selector"], [stringType], promise(browserTestInteractionTimingType)),
-    measureFill: namedFunction(["selector", "value"], [stringType, stringType], promise(browserTestInteractionTimingType)),
-    measurePress: namedFunction(["selector", "key"], [stringType, stringType], promise(browserTestInteractionTimingType)),
-});
-const browserTestStorageControllerType = object({
-    get: namedFunction(["key"], [stringType], promise(optional(stringType))),
-    set: namedFunction(["key", "value"], [stringType, stringType], promise(nullType)),
-    remove: namedFunction(["key"], [stringType], promise(nullType)),
-    clear: namedFunction([], [], promise(nullType)),
-});
-const browserTestNetworkControllerType = object({
-    respond: namedFunction(["path", "body", "status", "contentType", "delayMs"], [stringType, stringType, numberType, stringType, numberType], promise(nullType), 2),
-    clear: namedFunction([], [], promise(nullType)),
-});
-const webSocketConnectionIdentity = "velar/websocket#type:WebSocketConnection";
-const webSocketCloseIdentity = "velar/websocket#type:WebSocketClose";
-const webSocketConnectionType = { kind: "named", name: "WebSocketConnection", identity: webSocketConnectionIdentity };
-const webSocketCloseType = { kind: "named", name: "WebSocketClose", identity: webSocketCloseIdentity };
-const webSocketMessageType = { kind: "union", members: [stringType, bytesType] };
-const webSocketCloseFields = new Map([
-    ["code", numberType],
-    ["reason", stringType],
-]);
-const webSocketConnectionFields = new Map([
-    // D90 fr-4: one identity, one field roster. A Web connection is always an
-    // outbound `connect()` result, which was never upgraded from an Origin and
-    // therefore reads back null — the same value the Node runtime gives an
-    // outbound connection. Leaving the field off Web instead would make
-    // `velar/websocket#type:WebSocketConnection` mean two different things.
-    ["origin", optional(stringType)],
-    ["state", namedFunction([], [], stringType)],
-    ["send", namedFunction(["message"], [webSocketMessageType], promise(nullType))],
-    ["next", namedFunction([], [], promise(optional(webSocketMessageType)))],
-    ["closeInfo", namedFunction([], [], promise(webSocketCloseType))],
-    ["close", namedFunction(["code", "reason"], [numberType, stringType], promise(nullType), 0)],
-]);
-const webSocketConnectOptions = object({
-    timeout: optional(durationType),
-    maxMessageBytes: optional(numberType),
-    maxQueuedMessages: optional(numberType),
-    maxQueuedBytes: optional(numberType),
-    maxPendingSendBytes: optional(numberType),
-});
-const webSocketErrorIdentities = new Map([
-    ["WebSocketBackpressureError", "velar/websocket#class:WebSocketBackpressureError"],
-    ["WebSocketClosedError", "velar/websocket#class:WebSocketClosedError"],
-    ["WebSocketProtocolError", "velar/websocket#class:WebSocketProtocolError"],
-    ["WebSocketTimeoutError", "velar/websocket#class:WebSocketTimeoutError"],
-]);
-const webSocketErrorClass = (identity) => ({
-    identity,
-    parameters: [stringType],
-    parameterNames: ["message"],
-    requiredParameters: 0,
-    base: "Error",
-    abstract: false,
-    fields: new Map(),
-    getters: new Set(),
-    abstractGetters: new Set(),
-    methods: new Map(),
-    abstractMethods: new Set(),
-    staticFields: new Map(),
-    staticGetters: new Set(),
-    staticMethods: new Map(),
-});
-const realtimeWireType = webSocketMessageType;
-const realtimeCodecIdentity = "velar/realtime#type:RealtimeCodec";
-const realtimeClientIdentity = "velar/realtime#type:RealtimeClient";
-const realtimeFailureIdentity = "velar/realtime#type:RealtimeFailure";
-const realtimeOpenIdentity = "velar/realtime#type:RealtimeOpen";
-const realtimeClientStateIdentity = "velar/realtime#enum:RealtimeClientState";
-const realtimeFailureActionIdentity = "velar/realtime#enum:RealtimeClientFailureAction";
-const realtimeUnavailableIdentity = "velar/realtime#class:RealtimeUnavailableError";
-const realtimeClientStates = new Set(["idle", "connecting", "open", "reconnecting", "closed"]);
-const realtimeFailureActions = new Set(["continue", "reconnect", "stop"]);
-const realtimeClientStateType = { kind: "enum", name: "RealtimeClientState", identity: realtimeClientStateIdentity };
-const realtimeFailureActionType = { kind: "enum", name: "RealtimeClientFailureAction", identity: realtimeFailureActionIdentity };
-const realtimeFailureType = { kind: "named", name: "RealtimeFailure", identity: realtimeFailureIdentity };
-const realtimeOpenType = { kind: "named", name: "RealtimeOpen", identity: realtimeOpenIdentity };
-const realtimeCodecIncoming = { kind: "parameter", name: "Incoming", index: 0 };
-const realtimeCodecOutgoing = { kind: "parameter", name: "Outgoing", index: 1 };
-const realtimeClientOutgoing = { kind: "parameter", name: "T", index: 0 };
-const realtimeInput = { kind: "parameter", name: "Incoming", index: 0 };
-const realtimeOutput = { kind: "parameter", name: "Outgoing", index: 1 };
-function realtimeGenericApplication(name, identity, arguments_) {
-    const labels = arguments_.map((argument, index) => argument.kind === "parameter" ? argument.name : `T${index + 1}`);
-    return { kind: "named", name: `${name}<${labels.join(", ")}>`, identity, application: { declaration: identity, name, arguments: arguments_ } };
-}
-const realtimeCodecOf = (incoming, outgoing) => realtimeGenericApplication("RealtimeCodec", realtimeCodecIdentity, [incoming, outgoing]);
-const realtimeClientOf = (outgoing) => realtimeGenericApplication("RealtimeClient", realtimeClientIdentity, [outgoing]);
-const realtimeCodecTemplate = {
-    identity: realtimeCodecIdentity,
-    name: "RealtimeCodec",
-    parameterNames: ["Incoming", "Outgoing"],
-    parameterBounds: [null, null],
-    fields: new Map([
-        ["decode", namedFunction(["message"], [realtimeWireType], realtimeCodecIncoming)],
-        ["encode", namedFunction(["message"], [realtimeCodecOutgoing], realtimeWireType)],
-    ]),
-    readonlyFields: new Set(["decode", "encode"]),
-};
-const realtimeClientTemplate = {
-    identity: realtimeClientIdentity,
-    name: "RealtimeClient",
-    parameterNames: ["T"],
-    parameterBounds: [null],
-    fields: new Map([
-        ["state", namedFunction([], [], realtimeClientStateType)],
-        ["generation", namedFunction([], [], numberType)],
-        ["start", namedFunction([], [], promise(nullType))],
-        ["whenOpen", namedFunction([], [], promise(numberType))],
-        ["whenClosed", namedFunction([], [], promise(nullType))],
-        ["send", namedFunction(["message"], [realtimeClientOutgoing], promise(nullType))],
-        ["close", namedFunction(["code", "reason"], [numberType, stringType], promise(nullType), 0)],
-    ]),
-    readonlyFields: new Set(["state", "generation", "start", "whenOpen", "whenClosed", "send", "close"]),
-};
-const realtimeGenericTypes = new Map([
-    ["RealtimeCodec", realtimeCodecTemplate],
-    ["RealtimeClient", realtimeClientTemplate],
-]);
-const realtimeFailureFields = new Map([
-    ["phase", stringType],
-    ["error", errorType],
-    ["recoverable", boolType],
-]);
-const realtimeOpenFields = new Map([
-    ["generation", numberType],
-    ["reconnected", boolType],
-]);
-const realtimeClientOptions = object({
-    connectTimeout: optional(durationType),
-    maxMessageBytes: optional(numberType),
-    maxQueuedMessages: optional(numberType),
-    maxQueuedBytes: optional(numberType),
-    maxPendingSendBytes: optional(numberType),
-    reconnectDelays: optional({ kind: "list", element: durationType }),
-    reconnectJitter: optional(numberType),
-    retryInitial: optional(boolType),
-});
-const realtimeClientOutput = realtimeClientOf(realtimeOutput);
-const realtimeUrlType = { kind: "union", members: [stringType, namedFunction([], [], stringType)] };
-const realtimeReceive = namedFunction(["message", "client"], [realtimeInput, realtimeClientOutput], promise(nullType));
-const realtimeOpened = namedFunction(["client", "open"], [realtimeClientOutput, realtimeOpenType], promise(nullType));
-const realtimeFailed = namedFunction(["failure", "client"], [realtimeFailureType, realtimeClientOutput], promise(realtimeFailureActionType));
-const realtimeClosed = namedFunction(["client", "close"], [realtimeClientOutput, webSocketCloseType], promise(nullType));
-const realtimeStateChanged = namedFunction(["client", "state"], [realtimeClientOutput, realtimeClientStateType], promise(nullType));
-const realtimeClientFunction = {
-    kind: "function",
-    typeParameterNames: ["Incoming", "Outgoing"],
-    parameterNames: ["url", "codec", "receive", "opened", "failed", "closed", "stateChanged", "options"],
-    parameters: [
-        realtimeUrlType,
-        realtimeCodecOf(realtimeInput, realtimeOutput),
-        realtimeReceive,
-        optional(realtimeOpened),
-        optional(realtimeFailed),
-        optional(realtimeClosed),
-        optional(realtimeStateChanged),
-        realtimeClientOptions,
-    ],
-    requiredParameters: 3,
-    result: realtimeClientOutput,
-};
-const realtimeUnavailableClass = {
-    identity: realtimeUnavailableIdentity,
-    parameters: [stringType],
-    parameterNames: ["message"],
-    requiredParameters: 0,
-    base: "Error",
-    abstract: false,
-    fields: new Map(),
-    getters: new Set(),
-    abstractGetters: new Set(),
-    methods: new Map(),
-    abstractMethods: new Set(),
-    staticFields: new Map(),
-    staticGetters: new Set(),
-    staticMethods: new Map(),
-};
-export const webModuleInterfaces = new Map([
-    ["velar/websocket", moduleInterface(new Map([
-            ["WebSocketConnection", { kind: "typeObject", name: "WebSocketConnection", value: webSocketConnectionType }],
-            ["WebSocketClose", { kind: "typeObject", name: "WebSocketClose", value: webSocketCloseType }],
-            ...[...webSocketErrorIdentities].map(([name, identity]) => [name, { kind: "classConstructor", name, identity }]),
-            ["connect", namedFunction(["url", "options"], [stringType, webSocketConnectOptions], promise(webSocketConnectionType), 1)],
-        ]), new Map([...webSocketErrorIdentities].map(([name, identity]) => [name, webSocketErrorClass(identity)])), new Map([
-            ["WebSocketConnection", webSocketConnectionFields],
-            ["WebSocketClose", webSocketCloseFields],
-        ]), new Map([
-            ["WebSocketConnection", webSocketConnectionIdentity],
-            ["WebSocketClose", webSocketCloseIdentity],
-        ]), new Map(), new Map([
-            ["WebSocketConnection", new Set(webSocketConnectionFields.keys())],
-            ["WebSocketClose", new Set(webSocketCloseFields.keys())],
-        ]))],
-    ["velar/look", moduleInterface(lookModuleExports)],
-    ["velar/app", moduleInterface(new Map([
-            ["onError", namedFunction(["handler"], [functionType([appErrorType], unknownType)], cleanupType)],
-            ["reportError", namedFunction(["error", "phase", "detail"], [errorType, stringType, stringType], nullType, 1)],
-        ]))],
-    ["velar/config", moduleInterface(new Map([
-            ["publicConfig", namedIntrinsic("config.public", ["target"], [unknownType], unknownType)],
-            ["has", namedFunction(["key"], [stringType], boolType)],
-            ["keys", namedFunction([], [], arrayString)],
-        ]))],
-    ["velar/web", moduleInterface(new Map([
-            ["RouteContext", { kind: "typeObject", name: "RouteContext" }],
-            ["route", namedIntrinsic("web.route", ["path", "view"], [stringType, unknownType], routeType)],
-            ["lazy", namedIntrinsic("web.lazy", ["loader", "exportName", "loading", "failed"], [functionType([], promise(unknownType)), stringType, unknownType, unknownType], unknownType, 2)],
-            ["navigate", namedFunction(["to", "options"], [stringType, navigationOptionsType], nullType, 1)],
-            ["redirect", namedFunction(["to"], [stringType], nullType)],
-            ["back", namedFunction([], [], nullType)],
-            ["forward", namedFunction([], [], nullType)],
-            ["reload", namedFunction([], [], nullType)],
-            ["currentRoute", namedFunction([], [], routeContextType)],
-            ["announce", namedFunction(["message", "priority"], [stringType, stringType], nullType, 1)],
-            ["domId", namedFunction(["prefix"], [stringType], stringType, 0)],
-            ["Head", webComponentConstructor("Head", new Map([
-                    ["title", stringType], ["description", stringType], ["canonical", stringType], ["robots", stringType],
-                    ["image", stringType], ["themeColor", stringType], ["language", stringType],
-                ]), new Set(["title"]), null)],
-            ["Router", webComponentConstructor("Router", new Map([["routes", { kind: "list", element: routeType }], ["fallback", unknownType]]), new Set(["routes"]), null, "web.router")],
-            ["Link", webComponentConstructor("Link", new Map([["to", stringType], ["replace", boolType], ["class", optional(stringType)], ["look", optional({ kind: "named", name: "Look" })], ["children", nodeType]]), new Set(["to"]), null)],
-            ["NavLink", webComponentConstructor("NavLink", new Map([["to", stringType], ["exact", boolType], ["replace", boolType], ["class", optional(stringType)], ["look", optional({ kind: "named", name: "Look" })], ["children", nodeType]]), new Set(["to"]), null)],
-        ]), new Map(), new Map([["RouteContext", routeContextFields]]), new Map([
-            ["RouteContext", "@velarscript/web:velar/web#type:RouteContext"],
-        ]))],
-    ["velar/http", moduleInterface(new Map([
-            ["http", httpType],
-            ["formBody", namedFunction([], [], formBodyType)],
-            ["HttpTransportPhase", { kind: "enumObject", name: "HttpTransportPhase", identity: httpTransportPhaseIdentity, members: httpTransportPhaseMembers }],
-            ["HttpAbortError", { kind: "classConstructor", name: "HttpAbortError" }],
-            ["HttpResponseError", { kind: "classConstructor", name: "HttpResponseError" }],
-            ["HttpTransportError", { kind: "classConstructor", name: "HttpTransportError", identity: httpTransportErrorIdentity }],
-        ]), new Map([
-            ["HttpAbortError", {
-                    parameters: [stringType],
-                    parameterNames: ["reason"],
-                    requiredParameters: 1,
-                    base: "Error",
-                    abstract: false,
-                    fields: new Map([["reason", { mutable: false, type: stringType }]]),
-                    getters: new Set(),
-                    abstractGetters: new Set(),
-                    methods: new Map(),
-                    abstractMethods: new Set(),
-                    staticFields: new Map(),
-                    staticGetters: new Set(),
-                    staticMethods: new Map(),
-                }],
-            ["HttpResponseError", {
-                    parameters: [stringType, numberType, stringType, unknownType],
-                    parameterNames: ["message", "status", "url", "body"],
-                    requiredParameters: 3,
-                    base: "Error",
-                    abstract: false,
-                    fields: new Map([
-                        ["status", { mutable: false, type: numberType }],
-                        ["url", { mutable: false, type: stringType }],
-                        ["body", { mutable: false, type: unknownType }],
-                    ]),
-                    getters: new Set(),
-                    abstractGetters: new Set(),
-                    methods: new Map(),
-                    abstractMethods: new Set(),
-                    staticFields: new Map(),
-                    staticGetters: new Set(),
-                    staticMethods: new Map(),
-                }],
-            ["HttpTransportError", {
-                    identity: httpTransportErrorIdentity,
-                    parameters: [stringType, httpTransportPhaseType],
-                    parameterNames: ["message", "phase"],
-                    requiredParameters: 2,
-                    base: "Error",
-                    abstract: false,
-                    fields: new Map([["phase", { mutable: false, type: httpTransportPhaseType }]]),
-                    getters: new Set(),
-                    abstractGetters: new Set(),
-                    methods: new Map(),
-                    abstractMethods: new Set(),
-                    staticFields: new Map(),
-                    staticGetters: new Set(),
-                    staticMethods: new Map(),
-                }],
-        ]), new Map(), new Map(), new Map([["HttpTransportPhase", { identity: httpTransportPhaseIdentity, members: httpTransportPhaseMembers, wireValues: httpTransportPhaseWireValues }]]))],
-    ["velar/storage", moduleInterface(new Map([
-            ["storage", storageType],
-            ["session", storageType],
-            ["database", namedFunction(["name"], [stringType], databaseType)],
-            ["StorageQuotaError", { kind: "classConstructor", name: "StorageQuotaError", identity: storageQuotaErrorIdentity }],
-            ["StorageTransactionError", { kind: "classConstructor", name: "StorageTransactionError", identity: storageTransactionErrorIdentity }],
-            ["StorageUpgradeError", { kind: "classConstructor", name: "StorageUpgradeError", identity: storageUpgradeErrorIdentity }],
-        ]), new Map([
-            ["StorageQuotaError", storageErrorClass(storageQuotaErrorIdentity)],
-            ["StorageTransactionError", storageErrorClass(storageTransactionErrorIdentity)],
-            ["StorageUpgradeError", storageErrorClass(storageUpgradeErrorIdentity)],
-        ]))],
-    ["velar/forms", moduleInterface(new Map([
-            ["values", namedFunction(["form"], [elementType], formValuesType)],
-            ["read", namedIntrinsic("forms.read", ["form", "target"], [elementType, unknownType], unknownType)],
-            ["fieldValue", namedFunction(["form", "name"], [elementType, stringType], optional(unknownType))],
-            ["textValue", namedFunction(["form", "name", "fallback"], [elementType, stringType, stringType], stringType, 2)],
-            ["numberValue", namedFunction(["form", "name"], [elementType, stringType], optional(numberType))],
-            ["checkedValue", namedFunction(["form", "name"], [elementType, stringType], boolType)],
-            ["fieldValues", namedFunction(["form", "name"], [elementType, stringType], arrayString)],
-            ["setError", namedFunction(["form", "name", "message"], [elementType, stringType, stringType], nullType)],
-            ["clearError", namedFunction(["form", "name"], [elementType, stringType], nullType)],
-            ["clearErrors", namedFunction(["form"], [elementType], nullType)],
-            ["errors", namedFunction(["form"], [elementType], mapString(stringType))],
-            ["focusFirstError", namedFunction(["form"], [elementType], boolType)],
-            ["setPending", namedFunction(["form", "pending"], [elementType, boolType], nullType)],
-            ["reset", namedFunction(["form"], [elementType], nullType)],
-        ]))],
-    ["velar/browser", moduleInterface(new Map([
-            ["after", namedFunction(["duration", "callback"], [durationType, functionType([], unknownType)], cleanupType)],
-            ["location", namedFunction([], [], browserLocationType)],
-            ["environment", namedFunction([], [], browserEnvironmentType)],
-            // D104 rule 4: the two halves of the system clipboard read as a pair. The
-            // write used to be `copyText`, and a consumer surveying this table for a
-            // "copy this answer" button found `readClipboardText`, `clipboardText` and
-            // `setClipboardText` — a read and an event pair — and concluded the module
-            // could not write. The capability was there under a name that did not
-            // answer the question being asked, which is the same defect as a missing
-            // capability from where the author is standing.
-            ["readClipboardText", namedFunction([], [], promise(stringType))],
-            ["writeClipboardText", namedFunction(["value"], [stringType], promise(nullType))],
-            ["open", namedFunction(["url", "target"], [stringType, stringType], nullType, 1)],
-            ["scrollTo", namedFunction(["x", "y", "behavior"], [numberType, numberType, stringType], nullType, 2)],
-            ["scrollIntoView", namedFunction(["element", "behavior"], [webElementType, stringType], nullType, 1)],
-            ["scrollMetrics", namedFunction(["element"], [webElementType], scrollMetricsType)],
-            ["scrollElementTo", namedFunction(["element", "x", "y", "behavior"], [webElementType, numberType, numberType, stringType], nullType, 3)],
-            ["focus", namedFunction(["element", "preventScroll"], [webElementType, boolType], nullType, 1)],
-            ["blur", namedFunction(["element"], [webElementType], nullType)],
-            ["measure", namedFunction(["element"], [webElementType], rectType)],
-            ["textSelection", namedFunction(["element"], [textAreaElementType], textSelectionType)],
-            ["setTextSelection", namedFunction(["element", "start", "end", "direction"], [textAreaElementType, numberType, numberType, stringType], nullType, 3)],
-            ["clipboardText", namedFunction(["event"], [{ kind: "named", name: "ClipboardEvent" }], stringType)],
-            ["setClipboardText", namedFunction(["event", "value"], [{ kind: "named", name: "ClipboardEvent" }, stringType], nullType)],
-            ["capturePointer", namedFunction(["element", "pointerId"], [webElementType, numberType], nullType)],
-            ["releasePointer", namedFunction(["element", "pointerId"], [webElementType, numberType], nullType)],
-            ["media", namedFunction(["query"], [stringType], boolType)],
-            ["watchIntersection", namedFunction(["element", "callback", "options"], [webElementType, functionType([intersectionEntryType], unknownType), intersectionOptionsType], cleanupType, 2)],
-            ["watchMedia", namedFunction(["query", "callback"], [stringType, functionType([boolType], unknownType)], cleanupType)],
-            ["watchOnline", namedFunction(["callback"], [functionType([boolType], unknownType)], cleanupType)],
-            ["watchVisibility", namedFunction(["callback"], [functionType([boolType], unknownType)], cleanupType)],
-            ["showDialog", namedFunction(["dialog"], [dialogElementType], nullType)],
-            ["closeDialog", namedFunction(["dialog", "result"], [dialogElementType, stringType], nullType, 1)],
-            ["dialogResult", namedFunction(["dialog"], [dialogElementType], stringType)],
-            ["every", namedFunction(["duration", "callback"], [durationType, functionType([], unknownType)], cleanupType)],
-            ["frame", namedFunction([], [], promise(numberType))],
-        ]))],
-    ["velar/files", moduleInterface(new Map([
-            ["pick", namedFunction(["options"], [fileOptionsType], promise(fileArrayType), 0)],
-            ["readText", namedFunction(["file", "maxBytes"], [fileType, numberType], promise(stringType), 1)],
-            ["readDataUrl", namedFunction(["file", "maxBytes"], [fileType, numberType], promise(stringType), 1)],
-            ["download", namedFunction(["name", "data", "mime"], [stringType, stringType, stringType], nullType, 2)],
-        ]))],
-    ["velar/realtime", moduleInterface(new Map([
-            ["RealtimeClient", { kind: "typeObject", name: "RealtimeClient", value: realtimeClientOf(realtimeClientOutgoing) }],
-            ["RealtimeClientFailureAction", { kind: "enumObject", name: "RealtimeClientFailureAction", identity: realtimeFailureActionIdentity, members: realtimeFailureActions }],
-            ["RealtimeClientState", { kind: "enumObject", name: "RealtimeClientState", identity: realtimeClientStateIdentity, members: realtimeClientStates }],
-            ["RealtimeCodec", { kind: "typeObject", name: "RealtimeCodec", value: realtimeCodecOf(realtimeCodecIncoming, realtimeCodecOutgoing) }],
-            ["RealtimeFailure", { kind: "typeObject", name: "RealtimeFailure", value: realtimeFailureType }],
-            ["RealtimeOpen", { kind: "typeObject", name: "RealtimeOpen", value: realtimeOpenType }],
-            ["RealtimeUnavailableError", { kind: "classConstructor", name: "RealtimeUnavailableError", identity: realtimeUnavailableIdentity }],
-            ["eventStream", namedFunction(["url", "handlers", "credentials"], [stringType, eventStreamHandlersType, boolType], eventStreamType, 1)],
-            ["realtimeClient", realtimeClientFunction],
-        ]), new Map([["RealtimeUnavailableError", realtimeUnavailableClass]]), new Map([
-            ["RealtimeFailure", realtimeFailureFields],
-            ["RealtimeOpen", realtimeOpenFields],
-        ]), new Map([
-            ["RealtimeFailure", realtimeFailureIdentity],
-            ["RealtimeOpen", realtimeOpenIdentity],
-        ]), new Map([
-            ["RealtimeClientFailureAction", { identity: realtimeFailureActionIdentity, members: realtimeFailureActions, wireValues: new Map([...realtimeFailureActions].map((member) => [member, member])) }],
-            ["RealtimeClientState", { identity: realtimeClientStateIdentity, members: realtimeClientStates, wireValues: new Map([...realtimeClientStates].map((member) => [member, member])) }],
-        ]), new Map([
-            ["RealtimeFailure", new Set(realtimeFailureFields.keys())],
-            ["RealtimeOpen", new Set(realtimeOpenFields.keys())],
-        ]), realtimeGenericTypes)],
-    [BROWSER_TEST_MODULE, moduleInterface(new Map([
-            ["browser", browserTestControllerType],
-            ["localStorage", browserTestStorageControllerType],
-            ["sessionStorage", browserTestStorageControllerType],
-            ["network", browserTestNetworkControllerType],
-        ]))],
-]);
-function moduleInterface(exports, classes = new Map(), namedTypes = new Map(), namedTypeIdentities = new Map(), enums = new Map(), namedTypeReadonlyFields = new Map(), genericTypes = new Map()) {
-    return { exports, mutableExports: new Set(), reactiveExports: new Map(), reExports: new Map(), namedTypes, namedTypeReadonlyFields, namedTypeIdentities, genericTypes, typeAliases: new Map(), enums, classes, tests: [], extensionExports: new Map(), extensionData: new Map() };
-}
-const webLookHookDocumentation = Object.fromEntries([...LOOK_HOOKS].map((name) => [
-    `@${name}`,
-    [
-        `Matches the element's compiler-owned \`${name}\` state inside a \`look:\` condition. It is not a decorator, variable, or runtime callback.`,
-        "",
-        "```velar",
-        `if @${name}:`,
-        "    color = \"blue\"",
-        "```",
-        "",
-        "The condition lowers to the corresponding live CSS state. A Look literal cannot read reactive application state; apply a different Look from JSX for that.",
-    ].join("\n"),
-]));
-const webLookTargetDocumentation = Object.fromEntries([...LOOK_TARGETS].map((name) => [
-    `@${name}`,
-    [
-        `Selects the compiler-owned \`::${name}\` visual target inside a \`look:\` value. It is not a decorator or user-defined nested selector.`,
-        "",
-        "```velar",
-        `@${name}:`,
-        "    content = \"\"",
-        "```",
-        "",
-        "Only the closed target vocabulary accepted by the Web compiler is available, and every nested property remains checked by Look.",
-    ].join("\n"),
-]));
-const webKeywordDocumentation = Object.freeze({
-    component: "Declares a compiler-managed Web component. Props are its parameters, the body initializes once per mounted instance, and JSX is returned directly.\n\n```velar\ncomponent Greeting(name: string):\n    return <p>Hello {name}</p>\n```",
-    state: "Declares writable reactive state. Reading it records a dependency and assigning it schedules the owning Web update.\n\n```velar\nstate count = 0\n```",
-    computed: "Declares a read-only reactive value derived synchronously from what its initializer reads. Read the value directly; it is not a function.\n\n```velar\ncomputed doubled = count * 2\n```",
-    resource: "Declares component-owned asynchronous data with reactive `value`, `loading`, `ready`, `error`, and `reload` fields.\n\n```velar\nresource article: Article = loadArticle(id)\n```",
-    action: "Declares an asynchronous user operation with reactive `pending` and `error` fields.\n\n```velar\naction save():\n    await saveDraft(draft)\n```",
-    watch: "Runs after the watched reactive path changes and the corresponding DOM update commits. Watch a state/computed path, not an arbitrary effectful expression.\n\n```velar\nwatch query as current, previous:\n    print(f\"{previous} -> {current}\")\n```",
-    "@mounted": "Runs once after the component DOM has been inserted. It is a compiler-owned component lifecycle role, not a decorator or callable hook, and its body may `await`.\n\n```velar\n@mounted:\n    await focusInitialField()\n```",
-    "@cleanup": "Runs once before the component and its owned resources are destroyed. It is a compiler-owned component lifecycle role, not a decorator or callable hook, and cleanup is synchronous.\n\n```velar\n@cleanup:\n    subscription.close()\n```",
-    exposes: "Declares the explicit typed Handle a component permits a parent to receive through JSX `ref`.\n\n```velar\ncomponent Dialog() exposes DialogHandle:\n```",
-    expose: "Provides the Handle value promised by the component's `exposes` clause.\n\n```velar\nexpose {open, close}\n```",
-    look: "Builds a typed, composable Web appearance value. Properties, units, conditions, targets, and imported `velar/look` builders are checked by the compiler.\n\n```velar\nconst card = look:\n    padding = 16px\n    if @hover:\n        color = \"blue\"\n```",
-    keyframes: "Builds checked animation stops as a first-class `Keyframes` value for the `animate` builder.\n\n```velar\nconst spin = keyframes:\n    from:\n        rotate = 0deg\n    to:\n        rotate = 1turn\n```",
-    css: "Marks an explicit unsafe native CSS import or raw block. Prefer Look; when CSS is necessary, its order before or after generated Look output must be stated in source.",
-    "jsx:on:*": "Attaches a checked DOM event handler. Write `on:event` and optional `.prevent`, `.stop`, `.once`, `.capture`, or `.self` modifiers.\n\n```velar\n<button on:click.prevent={save}>Save</button>\n```",
-    "jsx:bind:value": "Two-way binds the value of an input, textarea, or select to writable state.\n\n```velar\n<input bind:value={name} />\n```",
-    "jsx:bind:checked": "Two-way binds an input's checked flag to writable bool state.\n\n```velar\n<input type=\"checkbox\" bind:checked={enabled} />\n```",
-    "jsx:bind:group": "Binds a radio choice or checkbox group to writable group state using the element's checked value contract.",
-    "jsx:class:*": "Adds or removes one CSS class from a bool expression. The suffix is the class name.\n\n```velar\n<section class:active={selected}></section>\n```",
-    "jsx:look": "Applies a `Look`, optional Look, or ordered list of Look values to this JSX element.\n\n```velar\n<article look={cardLook}></article>\n```",
-    "jsx:look:*": "Applies one checked Look property as a normal-priority JSX visual directive. Prefer a named Look for conditions, targets, or several properties.",
-    "jsx:style:*": "Applies one checked high-priority inline visual override. Prefer Look for ordinary styling.",
-    "jsx:ref": "Stores the mounted native element or exposed component Handle in a mutable optional `let` binding, then restores `null` during cleanup.",
-    "jsx:key": "Gives a repeated JSX child stable identity. Keys must be strings, numbers, or string-backed enum values and must be stable across renders.",
-    "jsx:host": "Marks the one native element that receives a component's forwarded host attributes and events.",
-    "jsx:unsafe:html": "Writes explicitly unsafe HTML text into a native element. The value must be string or string?; use ordinary JSX for trusted structured content.",
-    ...webLookHookDocumentation,
-    ...webLookTargetDocumentation,
-    ...webLookPropertyDocumentation,
-});
+export const webModuleInterfaces = new Map(webModuleEntries);
 export const velarCompilerExtension = Object.freeze({
     id: "@velarscript/web",
     contract: Object.freeze({ protocolVersion: 1, apiVersion: VELAR_WEB_API_VERSION, kind: "application", extends: Object.freeze({}) }),