@velarscript/web 0.10.1

package/dist/compiler.js

@@ -0,0 +1,715 @@
+import { optionalOf as optional } from "@velarscript/compiler";
+import { inferWebIntrinsic, routeContextIdentity, 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_VOID_ELEMENTS } from "./elements.js";
+import { WebJavaScriptEmitter } from "./emitter.js";
+import { velarWebProjectEditorExtension } from "./editor.js";
+import { velarWebInspectionExtension } from "./inspection.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_MEDIA_SUBJECTS, LOOK_PUBLIC_TYPE_NAMES, LOOK_UNIT_TYPES } from "./look.js";
+import { CACHED_INTRINSIC_TYPE, isWebTypeAssignable, resolveWebTypeSyntax, WEB_OWNED_TYPE_NAMES, webComponentConstructor, webNodeType } from "./types.js";
+export const VELAR_WEB_API_VERSION = "0.10";
+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 anyType = { kind: "any" };
+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 imageType = { kind: "named", name: "Image" };
+const trackType = { kind: "named", name: "Track" };
+const trackListType = { kind: "named", name: "TrackList" };
+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] };
+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, result, 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,
+    };
+}
+const unknownType = { kind: "unknown" };
+const webGlobals = new Map([
+    ["mount", namedFunction(["node", "target"], [nodeType, mountTargetType], nullType)],
+    ["tick", namedFunction([], [], { kind: "promise", value: nullType })],
+    // D71 rule 183: the word `computed` names the declaration; the function that
+    // returns a passable cached reader is `cached`. `computed` is a contextual
+    // keyword now rather than a global, exactly as `state` is — the Web analyzer
+    // answers a leftover `computed(...)` with its migration on the way past.
+    ["cached", CACHED_INTRINSIC_TYPE],
+]);
+const lookModuleExports = new Map([
+    ...LOOK_PUBLIC_TYPE_NAMES.map((name) => [name, { kind: "typeObject", name, value: { kind: "named", name } }]),
+    ["color", lookBuilder("color", [stringType], colorType)],
+    ["rgb", lookBuilder("rgb", [numberType, numberType, numberType], colorType)],
+    ["rgba", lookBuilder("rgba", [numberType, numberType, numberType, numberType], colorType)],
+    ["hsl", lookBuilder("hsl", [numberType, numberType, numberType], colorType)],
+    ["alpha", lookBuilder("alpha", [colorInputType, numberType], colorType)],
+    ["lighten", lookBuilder("lighten", [colorInputType, numberType], colorType)],
+    ["darken", lookBuilder("darken", [colorInputType, numberType], colorType)],
+    ["border", lookBuilder("border", [lengthType, colorInputType, stringType], borderType)],
+    ["shadow", lookBuilder("shadow", [lengthType, lengthType, lengthType, colorInputType, lengthType, boolType], shadowType)],
+    ["linearGradient", lookBuilder("linearGradient", [angleType, colorInputType, colorInputType], imageType)],
+    ["asset", lookBuilder("asset", [stringType], imageType)],
+    ["minmax", lookBuilder("minmax", [trackInputType, trackInputType], trackType)],
+    ["repeat", lookBuilder("repeat", [repeatCountType, trackInputType], trackListType)],
+    ["tracks", lookBuilder("tracks", [trackInputType], trackListType, trackInputType)],
+    ["transition", lookBuilder("transition", [stringType, durationType, stringType, durationType], transitionType)],
+    ["spacing", lookBuilder("spacing", [lookScalarType, lookScalarType, lookScalarType, lookScalarType], spacingType)],
+    ["min", lookBuilder("min", [lengthType, lengthType], lengthType)],
+    ["max", lookBuilder("max", [lengthType, lengthType], lengthType)],
+    ["clamp", lookBuilder("clamp", [lengthType, lengthType, lengthType], lengthType)],
+    ["animate", lookBuilder("animate", [keyframesType, durationType, stringType, durationType, numberType, boolType, stringType, stringType], animationType)],
+]);
+// 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 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 httpTransportPhaseType = { kind: "enum", name: "HttpTransportPhase", identity: httpTransportPhaseIdentity };
+const httpTransportErrorIdentity = "velar/http#class:HttpTransportError";
+const httpResponseType = object({
+    ok: boolType,
+    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"], [anyType], promise(anyType)),
+});
+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"], [anyType], promise(anyType)),
+    cancel: namedFunction([], [], nullType),
+});
+const httpOptionsType = object({
+    headers: optional(mapString(stringType)),
+    body: optional(anyType),
+    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, anyType, anyType, numberType], anyType, 2)],
+        ["set", namedIntrinsic("storage.set", ["key", "value", "maxBytes"], [stringType, anyType, 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, anyType, anyType, 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, anyType, anyType, numberType], promise(anyType), 2),
+    set: namedIntrinsic("storage.set", ["key", "value", "maxBytes"], [stringType, anyType, 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(),
+    };
+}
+const routeType = object({
+    path: stringType,
+    component: anyType,
+});
+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,
+});
+const textSelectionType = object({ start: numberType, end: numberType, direction: stringType });
+const fileOptionsType = object({ accept: optional(stringType), multiple: optional(boolType) });
+const socketHandlersType = object({
+    open: optional(functionType([], unknownType)),
+    message: optional(functionType([stringType], unknownType)),
+    error: optional(functionType([stringType], unknownType)),
+    close: optional(functionType([numberType, stringType], unknownType)),
+});
+// D51 (audit 12): both realtime handles are standard capability handles that
+// publish `close()`, so `using` supplies their release contract (charter
+// section 16). They are declared structurally rather than as named types, and
+// the marker is what lets Core see them without ever detecting a shape.
+const socketType = capabilityHandle({
+    url: stringType,
+    state: namedFunction([], [], stringType),
+    send: namedFunction(["data"], [stringType], nullType),
+    sendJson: namedIntrinsic("realtime.sendJson", ["data"], [anyType], nullType),
+    close: namedFunction(["code", "reason"], [numberType, stringType], nullType, 0),
+});
+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)),
+});
+export const webModuleInterfaces = new Map([
+    ["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"], [anyType], anyType)],
+            ["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, anyType], routeType)],
+            ["lazy", namedIntrinsic("web.lazy", ["loader", "exportName", "loading", "failed"], [functionType([], promise(anyType)), stringType, anyType, anyType], anyType, 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", anyType]]), 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" }],
+            ["HttpError", { kind: "classConstructor", name: "HttpError" }],
+            ["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(),
+                }],
+            ["HttpError", {
+                    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 }]]))],
+    ["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, anyType], anyType)],
+            ["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)],
+            ["copyText", namedFunction(["value"], [stringType], promise(nullType))],
+            ["readClipboardText", namedFunction([], [], promise(stringType))],
+            ["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)],
+            ["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([
+            ["socket", namedFunction(["url", "handlers"], [stringType, socketHandlersType], socketType, 1)],
+            ["eventStream", namedFunction(["url", "handlers", "credentials"], [stringType, eventStreamHandlersType, boolType], eventStreamType, 1)],
+        ]))],
+    [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()) {
+    return { exports, mutableExports: new Set(), reactiveExports: new Map(), reExports: new Map(), namedTypes, namedTypeIdentities, typeAliases: new Map(), enums, classes, tests: [], extensionExports: new Map(), extensionData: new Map() };
+}
+export const velarCompilerExtension = Object.freeze({
+    id: "@velarscript/web",
+    contract: Object.freeze({ protocolVersion: 1, apiVersion: VELAR_WEB_API_VERSION, kind: "application", extends: Object.freeze({}) }),
+    capabilities: Object.freeze(["web"]),
+    formatting: Object.freeze({
+        angleBracketEmbedding: Object.freeze({ voidElements: WEB_VOID_ELEMENTS }),
+        scanOpaqueSource: scanWebUnsafeCssLiteral,
+    }),
+    lexical: Object.freeze({
+        // D30 item 16: every word the Web extension adds is contextual. Each is an
+        // ordinary name until its own declaration shape appears, so a Web module
+        // and a Core module accept exactly the same bindings.
+        contextualKeywords: WEB_CONTEXTUAL_KEYWORDS,
+        forbiddenIdentifiers: Object.freeze({
+            effect: "Effects are internal to @velarscript/web; use watch, @mounted, or @cleanup",
+            onMount: "Use the Web extension's component-level '@mounted:' block",
+            onMounted: "Use the Web extension's component-level '@mounted:' block",
+            on_mount: "Use the Web extension's component-level '@mounted:' block",
+        }),
+        numericSuffixes: new Set(LOOK_UNIT_TYPES.keys()),
+        scan: scanWebToken,
+    }),
+    parser: Object.freeze({
+        create(tokens, lexicalExtensions) {
+            return new VelarWebParser(tokens, lexicalExtensions);
+        },
+    }),
+    // D56 rule 129: the parser above adds eleven statement constructs to the
+    // language, and a coverage gate that only reads vocabulary tables cannot see
+    // one of them. This is how they are required of `examples/tour/`.
+    syntax: Object.freeze({
+        statementConstructs: WEB_STATEMENT_CONSTRUCTS,
+        statementConstructKey: webStatementConstructKey,
+    }),
+    analyzer: Object.freeze({
+        create(context, extensions) {
+            return new VelarWebAnalyzer(context, extensions);
+        },
+    }),
+    semantic: velarWebSemanticExtension,
+    inspection: velarWebInspectionExtension,
+    analysis: Object.freeze({
+        directAwaitExpression: webExpressionContainsDirectAwait,
+        directAwaitStatement: webStatementContainsDirectAwait,
+        // `Duration` is Core's own primitive; the Web extension reads it but does
+        // not register it a second time.
+        primitiveTypes: new Set([...WEB_OWNED_TYPE_NAMES].filter((name) => name !== "Duration")),
+        primitiveParents: new Map([
+            ["InputElement", new Set(["Element"])],
+            ["TextAreaElement", new Set(["InputElement"])],
+            ["CanvasElement", new Set(["Element"])],
+            ["DialogElement", new Set(["Element"])],
+            ["KeyboardEvent", new Set(["Event"])],
+            ["PointerEvent", new Set(["Event"])],
+            ["InputEvent", new Set(["Event"])],
+            ["CompositionEvent", new Set(["Event"])],
+            ["ClipboardEvent", new Set(["Event"])],
+        ]),
+        primitiveMutableFields: new Map([
+            ["InputElement", new Set(["value", "checked"])],
+            ["CanvasElement", new Set(["width", "height"])],
+        ]),
+        globals: webGlobals,
+        // D52 rule 114: `Look.spacing(...)` still parses, so it still has to be
+        // answered — with the named import that replaced it, and with the rewrite
+        // that gets there in one step.
+        retiredNamespaces: new Map([["Look", { module: "velar/look", members: LOOK_BUILDERS }]]),
+        // LOK-D4: the Look media subjects are matched by name inside a Look
+        // condition, ahead of ordinary lexical resolution. A user binding of the
+        // same name used to be reverse-shadowed with no diagnostic anywhere, so the
+        // three names are reserved in a Web module.
+        reservedBindings: new Set(["mount", "tick", "cached", ...LOOK_MEDIA_SUBJECTS.keys()]),
+        globalGuidance: new Map([
+            // D52 rule 114: the destination is the spelling that survives, so the
+            // guidance names the import outright rather than a prefix the next
+            // compile would retire in turn.
+            ...[...LOOK_BUILDERS].map((name) => [name, `Import the builder — import {${name}} from "velar/look" — then call ${name}(...)`]),
+            ["document", "Use JSX, refs, and velar/browser instead of the untyped document global"],
+            ["window", "Use velar/browser or an explicit JavaScript boundary instead of the untyped window global"],
+            ["navigator", "Use velar/browser instead of the navigator global"],
+            ["location", "Use velar/browser location() or velar/web navigation instead of the location global"],
+            ["history", "Use velar/web navigation instead of the history global"],
+            ["fetch", "Use velar/http instead of the raw fetch global"],
+        ]),
+        // A `.browser.test.vel` body runs in the test process and drives a page
+        // that already runs the built application, so the DOM globals do not point
+        // at velar/browser there: the door is velar/web-test.
+        globalGuidanceByPathSuffix: new Map([
+            [BROWSER_TEST_SOURCE_SUFFIX, new Map([
+                    ["document", browserTestDrivingGuidance("document")],
+                    ["window", browserTestDrivingGuidance("window")],
+                    ["navigator", browserTestDrivingGuidance("navigator")],
+                    ["localStorage", browserTestDrivingGuidance("localStorage")],
+                    ["sessionStorage", browserTestDrivingGuidance("sessionStorage")],
+                ])],
+        ]),
+        resolveTypeSyntax: resolveWebTypeSyntax,
+        isTypeAssignable: isWebTypeAssignable,
+        textForm(type) {
+            if (type.kind === "extension" && type.extensionId === "@velarscript/web")
+                return false;
+            if (type.kind !== "named" || !webOwnedNamedTypes.has(type.name))
+                return undefined;
+            return webTextFormTypes.has(type.name);
+        },
+        inferIntrinsic: inferWebIntrinsic,
+    }),
+    editor: Object.freeze({
+        project: velarWebProjectEditorExtension,
+        keywordDocumentation: Object.freeze({
+            component: "Declares a compiler-managed Web component that initializes once.",
+            state: "Declares writable reactive state in the current lexical scope.",
+            computed: "Declares a read-only reactive value derived from what its expression reads.",
+            resource: "Declares component-owned asynchronous data with reactive value, loading, ready, error, and reload fields.",
+            action: "Declares an asynchronous operation with reactive pending and error fields at module or component scope.",
+            watch: "Runs a block after a watched expression changes and DOM updates commit.",
+            "@mounted": "Runs once after the component DOM is inserted.",
+            "@cleanup": "Runs once before the component and its owned resources are destroyed.",
+            exposes: "Declares the explicit typed control Handle a component makes available through JSX ref.",
+            expose: "Provides the component Handle value declared by exposes.",
+            look: "Builds a typed, composable Web appearance value.",
+            keyframes: "Builds checked CSS animation stops as a first-class Keyframes value.",
+            css: "Marks an unsafe native CSS resource or inline raw block whose order against Look is explicit.",
+        }),
+        typeDocumentation: Object.freeze({
+            WebNode: "A value that can be rendered as component or JSX children.",
+            Element: "A general native element reference obtained through JSX `ref`.",
+            InputElement: "A native input, select, or textarea reference obtained through JSX `ref`.",
+            TextAreaElement: "A native textarea reference whose selection is accessed through velar/browser code-point APIs.",
+            CanvasElement: "A native canvas reference obtained through JSX `ref`.",
+            DialogElement: "A native dialog reference obtained from `<dialog ref={value}>` and operated through `velar/browser`.",
+            Blob: "An opaque binary HTTP body returned by `blob()` and accepted by HTTP request bodies.",
+            File: "An opaque selected file returned by `velar/files.pick()` with checked read-only metadata.",
+            Event: "A restricted Web event value exposed to VelarScript event handlers.",
+            Look: "A typed, composable Web appearance value applied through JSX look={...}.",
+        }),
+        completions: Object.freeze([
+            ...["component", "state", "computed", "resource", "action", "watch", "@mounted", "@cleanup", "exposes", "expose", "look", "keyframes"].map((label) => ({ label, kind: 14 })),
+            { label: "mount", kind: 3, detail: "mount(node, target) -> null" },
+            { label: "tick", kind: 3, detail: "tick() -> Promise<null>" },
+            { label: "cached", kind: 3, detail: "cached(() => T) -> () -> T" },
+            { label: "bind:value", kind: 10, detail: "Two-way string state binding" },
+            { label: "bind:checked", kind: 10, detail: "Two-way boolean state binding" },
+            { label: "bind:group", kind: 10, detail: "Two-way radio or checkbox group binding" },
+            { label: "on:click", kind: 10, detail: "DOM click handler" },
+            { label: "on:submit.prevent", kind: 10, detail: "DOM event with a preventDefault modifier" },
+            { label: "class:", kind: 10, detail: "Reactive class directive" },
+            { label: "look={value}", kind: 10, detail: "Apply a typed Look value" },
+            { label: "style:color={value}", kind: 10, detail: "High-priority checked inline Style compatibility override" },
+            { label: "import css unsafe", kind: 14, detail: "Import native CSS before Look output" },
+            { label: "unsafe css", kind: 14, detail: "Embed multiline raw CSS before or after Look output" },
+            { label: "after look", kind: 14, detail: "Place an unsafe CSS import after Look output" },
+            { label: "velar/look", kind: 9, detail: "Named visual builders and visual value Type objects" },
+            { label: "velar/app", kind: 9, detail: "Application error reports and explicit handler ownership" },
+            { label: "velar/config", kind: 9, detail: "Validated manifest-declared public application configuration" },
+            { label: "velar/web", kind: 9, detail: "Typed routing, navigation, metadata, and announcements" },
+            { label: "velar/forms", kind: 9, detail: "Form values, pending state, and accessible field errors" },
+            { label: "velar/http", kind: 9, detail: "Typed HTTP responses, runtime parsing, timeout, and cancellation" },
+            { label: "velar/storage", kind: 9, detail: "Typed local, session, scoped, observed, and IndexedDB storage" },
+            { label: "velar/browser", kind: 9, detail: "Browser state, cancellable timers, clipboard, media, visibility, layout, and frames" },
+            { label: "velar/files", kind: 9, detail: "Cross-browser file selection, reading, and downloads" },
+            { label: "velar/realtime", kind: 9, detail: "WebSocket and server-sent event connections" },
+            { label: BROWSER_TEST_MODULE, kind: 9, detail: `Restricted browser automation, imported only from a *${BROWSER_TEST_SOURCE_SUFFIX} module` },
+        ]),
+    }),
+    modules: Object.freeze({
+        apiVersion: VELAR_WEB_API_VERSION,
+        interfaces: webModuleInterfaces,
+        sources: webModuleSources,
+        dependencies: new Map([
+            ["velar/worker", ["velar/worker-manifest", "velar/task"]],
+            ["velar/http", ["velar/binary"]],
+            ["velar/storage", ["velar/binary"]],
+        ]),
+        source(specifier, projectConfig) {
+            return webModuleSource(specifier, (projectConfig ?? { base: "/" }));
+        },
+    }),
+    createEmitter(hints, forcedFunctionExports, resourceContents, extensionImports, options) {
+        return new WebJavaScriptEmitter(hints, forcedFunctionExports, resourceContents, extensionImports, options);
+    },
+});
+export { webModuleSource, webModuleSources };
+export { velarProjectExtension } from "./project-config.js";
+//# sourceMappingURL=compiler.js.map