@velarscript/web 0.10.1

package/dist/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"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"}

package/dist/semantic.d.ts

@@ -0,0 +1,3 @@
+import type { CompilerSemanticExtension } from "@velarscript/compiler/extension";
+export declare const velarWebSemanticExtension: CompilerSemanticExtension;
+//# sourceMappingURL=semantic.d.ts.map

package/dist/semantic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../src/semantic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,yBAAyB,EAI1B,MAAM,iCAAiC,CAAC;AAmDzC,eAAO,MAAM,yBAAyB,EAAE,yBA4GtC,CAAC"}

package/dist/semantic.js

@@ -0,0 +1,150 @@
+import { isWebExpression, isWebJsx, isWebKeyframes, isWebLook, isWebStatement, isWebUnit, } from "./ast.js";
+function visitJsx(expression, context) {
+    if (/^[A-Z]/u.test(expression.tag)) {
+        context.reference(expression.tag, expression.tagSpan);
+    }
+    for (const attribute of expression.attributes) {
+        const owner = context.jsxAttributeOwner(attribute.span, attribute.name);
+        if (owner) {
+            context.recordMemberReference(attribute.name, { start: attribute.span.start, end: attribute.span.start + attribute.name.length }, owner, "extension-property");
+        }
+        if (attribute.value && typeof attribute.value !== "string")
+            context.visitExpression(attribute.value);
+    }
+    for (const child of expression.children) {
+        if (child.kind === "JSXExpressionChild")
+            context.visitExpression(child.expression);
+        else if (child.kind === "ExtensionExpression:web:jsx")
+            context.visitExpression(child);
+    }
+}
+function visitWatch(statement, context) {
+    context.visitExpression(statement.expression);
+    context.enterScope(statement.span);
+    let cursor = statement.expression.span.end;
+    if (statement.currentName) {
+        const selection = context.nameSpan(statement.span, statement.currentName, cursor);
+        context.declare({ statement, role: "current" }, statement.currentName, "extension:parameter:web-watch-value", statement.span, selection);
+        cursor = selection.end;
+    }
+    if (statement.previousName) {
+        const selection = context.nameSpan(statement.span, statement.previousName, cursor);
+        context.declare({ statement, role: "previous" }, statement.previousName, "extension:parameter:web-watch-value", statement.span, selection);
+    }
+    for (const child of statement.body)
+        context.visitStatement(child);
+    context.exitScope();
+}
+export const velarWebSemanticExtension = Object.freeze({
+    predeclare(statement, context) {
+        if (!isWebStatement(statement))
+            return false;
+        if (statement.kind === "ExtensionStatement:web:action") {
+            context.declare(statement, statement.name, "extension:function:web-action", statement.span, context.nameSpan(statement.span, statement.name), { exported: statement.exported });
+            return true;
+        }
+        if (statement.kind === "ExtensionStatement:web:component") {
+            context.declare(statement, statement.name, "extension:function:web-component", statement.span, context.nameSpan(statement.span, statement.name), {
+                exported: statement.exported,
+                presentationKind: "class",
+            });
+            return true;
+        }
+        return false;
+    },
+    visitExpression(expression, context) {
+        if (isWebJsx(expression)) {
+            visitJsx(expression, context);
+            return true;
+        }
+        if (isWebLook(expression)) {
+            const visit = (entries) => {
+                for (const entry of entries) {
+                    if (entry.kind === "LookProperty" || entry.kind === "LookSpread")
+                        context.visitExpression(entry.value);
+                    else if (entry.kind === "LookIf") {
+                        context.visitExpression(entry.condition);
+                        visit(entry.thenEntries);
+                        visit(entry.elseEntries);
+                    }
+                    else
+                        visit(entry.entries);
+                }
+            };
+            visit(expression.entries);
+            return true;
+        }
+        if (isWebKeyframes(expression)) {
+            for (const stop of expression.stops)
+                for (const entry of stop.entries)
+                    context.visitExpression(entry.value);
+            return true;
+        }
+        return isWebUnit(expression) || (isWebExpression(expression) && expression.kind === "ExtensionExpression:web:look-hook");
+    },
+    visitStatement(statement, context) {
+        if (!isWebStatement(statement))
+            return false;
+        switch (statement.kind) {
+            case "ExtensionStatement:web:unsafe-css":
+                // Its payload is opaque CSS for editor language injection, never a
+                // VelarScript expression or reference graph.
+                return true;
+            case "ExtensionStatement:web:component":
+                context.enterScope(statement.span);
+                context.typeReferences(statement.handleType);
+                for (const parameter of statement.parameters) {
+                    if (parameter.defaultValue)
+                        context.visitExpression(parameter.defaultValue);
+                    context.typeReferences(parameter.type);
+                    context.declare(parameter, parameter.name, "parameter", parameter.span, { start: parameter.span.start, end: parameter.span.start + parameter.name.length }, { container: statement.name });
+                }
+                for (const item of statement.body) {
+                    if (item.kind === "ExtensionStatement:web:mounted" || item.kind === "ExtensionStatement:web:cleanup")
+                        context.visitBlock(item.body, item.span);
+                    else if (item.kind === "ExtensionStatement:web:expose")
+                        context.visitExpression(item.value);
+                    else
+                        context.visitStatement(item);
+                }
+                context.exitScope();
+                return true;
+            case "ExtensionStatement:web:state": {
+                context.visitExpression(statement.initializer);
+                context.typeReferences(statement.type);
+                context.declare(statement, statement.name, "extension:variable:web-state", statement.span, context.nameSpan(statement.span, statement.name), {
+                    exported: statement.exported,
+                    mutable: true,
+                    sourceTypeHint: true,
+                });
+                return true;
+            }
+            case "ExtensionStatement:web:computed": {
+                context.visitExpression(statement.initializer);
+                context.typeReferences(statement.type);
+                context.declare(statement, statement.name, "extension:variable:web-computed", statement.span, context.nameSpan(statement.span, statement.name), {
+                    exported: statement.exported,
+                    mutable: false,
+                    sourceTypeHint: true,
+                });
+                return true;
+            }
+            case "ExtensionStatement:web:resource":
+                context.visitExpression(statement.initializer);
+                context.typeReferences(statement.type);
+                context.declare(statement, statement.name, "extension:variable:web-resource", statement.span, context.nameSpan(statement.span, statement.name));
+                return true;
+            case "ExtensionStatement:web:action":
+                if (!context.hasDeclaration(statement))
+                    context.declare(statement, statement.name, "extension:function:web-action", statement.span, context.nameSpan(statement.span, statement.name), { exported: statement.exported });
+                context.visitFunction(statement);
+                return true;
+            case "ExtensionStatement:web:watch":
+                visitWatch(statement, context);
+                return true;
+            default:
+                return false;
+        }
+    },
+});
+//# sourceMappingURL=semantic.js.map

package/dist/semantic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic.js","sourceRoot":"","sources":["../src/semantic.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,56 @@
+import { type ExtensionTypeSyntaxResolver, type ExtensionValueType, type ValueType } from "@velarscript/compiler/extension";
+export declare const VELAR_WEB_TYPE_EXTENSION_ID = "@velarscript/web";
+/**
+ * D72 rule 186: every type name the Web extension publishes, in one table.
+ *
+ * It is the single source for three things that used to be written out
+ * separately and therefore drifted: the analysis contract's `primitiveTypes`,
+ * the `textForm` question, and the refusal of a user declaration that would
+ * shadow one of these names. D51 rule 109 settled that such a name is refused
+ * where it is introduced rather than where it is used — the use site can only
+ * report an ambiguity nobody can act on — and this is what makes that refusal
+ * follow the table instead of a hand-copied list of six event types.
+ *
+ * `Component` and `WebNode` belong here for the same reason the rest do: a user
+ * `type Component:` loses to the extension's reading at every use.
+ */
+export declare const WEB_OWNED_TYPE_NAMES: ReadonlySet<string>;
+/** The Web event hierarchy, derived from the published table rather than restated. */
+export declare const WEB_EVENT_TYPE_NAMES: ReadonlySet<string>;
+/**
+ * D71 rule 184: the interface annotation that says an export is a `computed`
+ * declaration rather than a `state` one. Both travel through `reactiveExports`
+ * so an imported bare read lowers through `.get()`, and this is what tells the
+ * importing module that the derived one is read-only — without it, `bind={...}`
+ * on an imported derived value would compile to a write nothing receives.
+ */
+export declare const WEB_COMPUTED_EXPORT: Readonly<{
+    velarWebExport: "computed";
+}>;
+export declare function isWebComputedExport(value: unknown): boolean;
+export declare const CACHED_INTRINSIC_TYPE: ValueType;
+export type WebExtensionType = ExtensionValueType & {
+    readonly extensionId: typeof VELAR_WEB_TYPE_EXTENSION_ID;
+};
+export type WebNodeType = WebExtensionType & {
+    readonly family: "node";
+    readonly role: "value";
+};
+export type WebComponentType = WebExtensionType & {
+    readonly family: "component";
+    readonly role: "contract" | "constructor";
+};
+export declare const webNodeType: WebNodeType;
+export declare function webComponentContract(properties?: ReadonlyMap<string, ValueType>, requiredProperties?: ReadonlySet<string>, handle?: ValueType | null): WebComponentType;
+export declare function webComponentConstructor(name: string, properties: ReadonlyMap<string, ValueType>, requiredProperties: ReadonlySet<string>, handle: ValueType | null, intrinsic?: string): WebComponentType;
+export declare function isWebExtensionType(type: ValueType): type is WebExtensionType;
+export declare function isWebNodeType(type: ValueType): type is WebNodeType;
+export declare function isWebComponentType(type: ValueType): type is WebComponentType;
+export declare function isWebComponentConstructor(type: ValueType): type is WebComponentType;
+export declare function webComponentName(type: WebComponentType): string | null;
+export declare function webComponentHandle(type: WebComponentType): ValueType | null;
+export declare function webComponentIntrinsic(type: WebComponentType): string | null;
+export declare const resolveWebTypeSyntax: ExtensionTypeSyntaxResolver;
+export declare function normalizeWebComponentType(type: WebComponentType, normalizeProperty: (type: ValueType) => ValueType, normalizeArgument?: (type: ValueType) => ValueType): WebComponentType;
+export declare function isWebTypeAssignable(actual: ExtensionValueType, expected: ExtensionValueType, assign: (actual: ValueType, expected: ValueType) => boolean): boolean | undefined;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,2BAA2B,EAChC,KAAK,kBAAkB,EACvB,KAAK,SAAS,EACf,MAAM,iCAAiC,CAAC;AAGzC,eAAO,MAAM,2BAA2B,qBAAqB,CAAC;AAE9D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAMnD,CAAC;AAEH,sFAAsF;AACtF,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAEpD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;oBAAmC,UAAU;EAAY,CAAC;AAE1F,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAG3D;AAWD,eAAO,MAAM,qBAAqB,EAAE,SAOlC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,kBAAkB,GAAG;IAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,2BAA2B,CAAA;CAAE,CAAC;AACjH,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AACjG,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa,CAAA;CAAE,CAAC;AAE9H,eAAO,MAAM,WAAW,EAAE,WASxB,CAAC;AAYH,wBAAgB,oBAAoB,CAClC,UAAU,GAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAa,EACtD,kBAAkB,GAAE,WAAW,CAAC,MAAM,CAAa,EACnD,MAAM,GAAE,SAAS,GAAG,IAAW,GAC9B,gBAAgB,CAYlB;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,EAC1C,kBAAkB,EAAE,WAAW,CAAC,MAAM,CAAC,EACvC,MAAM,EAAE,SAAS,GAAG,IAAI,EACxB,SAAS,CAAC,EAAE,MAAM,GACjB,gBAAgB,CAalB;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,IAAI,gBAAgB,CAE5E;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,IAAI,WAAW,CAElE;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,IAAI,gBAAgB,CAG5E;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,IAAI,gBAAgB,CAEnF;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAItE;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,GAAG,SAAS,GAAG,IAAI,CAE3E;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAE3E;AAED,eAAO,MAAM,oBAAoB,EAAE,2BAiBlC,CAAC;AAEF,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,gBAAgB,EACtB,iBAAiB,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,SAAS,EACjD,iBAAiB,GAAE,CAAC,IAAI,EAAE,SAAS,KAAK,SAA6B,GACpE,gBAAgB,CAWlB;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,kBAAkB,EAC5B,MAAM,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,KAAK,OAAO,GAC1D,OAAO,GAAG,SAAS,CAerB"}

package/dist/types.js

@@ -0,0 +1,178 @@
+import { optionalOf, stringType, } from "@velarscript/compiler/extension";
+import { LOOK_PUBLIC_TYPE_NAMES } from "./look.js";
+export const VELAR_WEB_TYPE_EXTENSION_ID = "@velarscript/web";
+/**
+ * D72 rule 186: every type name the Web extension publishes, in one table.
+ *
+ * It is the single source for three things that used to be written out
+ * separately and therefore drifted: the analysis contract's `primitiveTypes`,
+ * the `textForm` question, and the refusal of a user declaration that would
+ * shadow one of these names. D51 rule 109 settled that such a name is refused
+ * where it is introduced rather than where it is used — the use site can only
+ * report an ambiguity nobody can act on — and this is what makes that refusal
+ * follow the table instead of a hand-copied list of six event types.
+ *
+ * `Component` and `WebNode` belong here for the same reason the rest do: a user
+ * `type Component:` loses to the extension's reading at every use.
+ */
+export const WEB_OWNED_TYPE_NAMES = new Set([
+    "WebNode", "Component",
+    "Element", "InputElement", "TextAreaElement", "CanvasElement", "DialogElement",
+    "Blob", "File",
+    "Event", "KeyboardEvent", "PointerEvent", "InputEvent", "CompositionEvent", "ClipboardEvent",
+    ...LOOK_PUBLIC_TYPE_NAMES,
+]);
+/** The Web event hierarchy, derived from the published table rather than restated. */
+export const WEB_EVENT_TYPE_NAMES = new Set([...WEB_OWNED_TYPE_NAMES].filter((name) => name === "Event" || name.endsWith("Event")));
+/**
+ * D71 rule 184: the interface annotation that says an export is a `computed`
+ * declaration rather than a `state` one. Both travel through `reactiveExports`
+ * so an imported bare read lowers through `.get()`, and this is what tells the
+ * importing module that the derived one is read-only — without it, `bind={...}`
+ * on an imported derived value would compile to a write nothing receives.
+ */
+export const WEB_COMPUTED_EXPORT = Object.freeze({ velarWebExport: "computed" });
+export function isWebComputedExport(value) {
+    return typeof value === "object" && value !== null
+        && value.velarWebExport === "computed";
+}
+/**
+ * D71 rule 183: `cached(read)` returns the reader it caches. The retired
+ * `computed(...)` spelling is inferred as the same intrinsic while its
+ * migration diagnostic is produced, so the rest of the module still type-checks
+ * against one truthful signature rather than against an unknown name.
+ */
+const cachedUnknownType = Object.freeze({ kind: "unknown" });
+const cachedReaderType = Object.freeze({ kind: "function", parameters: [], requiredParameters: 0, result: cachedUnknownType });
+export const CACHED_INTRINSIC_TYPE = Object.freeze({
+    kind: "intrinsic",
+    name: "reactive.computed",
+    parameterNames: ["read"],
+    parameters: [cachedReaderType],
+    requiredParameters: 1,
+    result: cachedReaderType,
+});
+export const webNodeType = Object.freeze({
+    kind: "extension",
+    extensionId: VELAR_WEB_TYPE_EXTENSION_ID,
+    family: "node",
+    role: "value",
+    properties: new Map(),
+    requiredProperties: new Set(),
+    arguments: [],
+    display: { kind: "named", name: "WebNode" },
+});
+const componentDisplay = Object.freeze({
+    kind: "properties",
+    name: "Component",
+    result: "WebNode",
+    hiddenOptionalProperties: new Map([
+        ["class", "string?"],
+        ["look", "Look?"],
+    ]),
+});
+export function webComponentContract(properties = new Map(), requiredProperties = new Set(), handle = null) {
+    return {
+        kind: "extension",
+        extensionId: VELAR_WEB_TYPE_EXTENSION_ID,
+        family: "component",
+        role: "contract",
+        properties,
+        requiredProperties,
+        arguments: handle ? [handle] : [],
+        metadata: { semanticSymbolKind: "extension:function:web-component" },
+        display: componentDisplay,
+    };
+}
+export function webComponentConstructor(name, properties, requiredProperties, handle, intrinsic) {
+    return {
+        kind: "extension",
+        extensionId: VELAR_WEB_TYPE_EXTENSION_ID,
+        family: "component",
+        role: "constructor",
+        nominal: name,
+        properties,
+        requiredProperties,
+        arguments: handle ? [handle] : [],
+        metadata: { semanticSymbolKind: "extension:function:web-component", ...(intrinsic ? { intrinsic } : {}) },
+        display: { kind: "constructor", prefix: "component", name },
+    };
+}
+export function isWebExtensionType(type) {
+    return type.kind === "extension" && type.extensionId === VELAR_WEB_TYPE_EXTENSION_ID;
+}
+export function isWebNodeType(type) {
+    return isWebExtensionType(type) && type.family === "node" && type.role === "value";
+}
+export function isWebComponentType(type) {
+    return isWebExtensionType(type) && type.family === "component"
+        && (type.role === "contract" || type.role === "constructor");
+}
+export function isWebComponentConstructor(type) {
+    return isWebComponentType(type) && type.role === "constructor";
+}
+export function webComponentName(type) {
+    return type.role === "constructor"
+        ? type.nominal ?? (type.display.kind === "constructor" ? type.display.name : null)
+        : null;
+}
+export function webComponentHandle(type) {
+    return type.arguments[0] ?? null;
+}
+export function webComponentIntrinsic(type) {
+    return type.metadata?.intrinsic ?? null;
+}
+export const resolveWebTypeSyntax = (syntax, resolve) => {
+    if (syntax.kind === "NamedTypeSyntax") {
+        if (syntax.name === "WebNode")
+            return webNodeType;
+        if (syntax.name === "Component")
+            return webComponentContract();
+        return undefined;
+    }
+    if (syntax.kind !== "GenericTypeSyntax" || syntax.name !== "Component")
+        return undefined;
+    const signature = syntax.arguments[0];
+    if (signature?.kind !== "FunctionTypeSyntax" || signature.parameters.some((parameter) => !parameter.name)) {
+        return webComponentContract();
+    }
+    const parameters = signature.parameters.filter((parameter) => !parameter.rest);
+    return webComponentContract(new Map(parameters.map((parameter) => [parameter.name, resolve(parameter.type)])), new Set(parameters.filter((parameter) => !parameter.optional).map((parameter) => parameter.name)), syntax.arguments[1] ? resolve(syntax.arguments[1]) : null);
+};
+export function normalizeWebComponentType(type, normalizeProperty, normalizeArgument = normalizeProperty) {
+    const properties = new Map([...type.properties]
+        .map(([name, value]) => [name, normalizeProperty(value)]));
+    if (!properties.has("class"))
+        properties.set("class", optionalOf(stringType));
+    if (!properties.has("look"))
+        properties.set("look", optionalOf({ kind: "named", name: "Look" }));
+    const handle = webComponentHandle(type);
+    return {
+        ...type,
+        properties,
+        arguments: handle ? [normalizeArgument(handle)] : [],
+    };
+}
+export function isWebTypeAssignable(actual, expected, assign) {
+    if (actual.extensionId !== VELAR_WEB_TYPE_EXTENSION_ID || expected.extensionId !== VELAR_WEB_TYPE_EXTENSION_ID)
+        return undefined;
+    if (actual.family !== expected.family)
+        return false;
+    if (actual.family === "node")
+        return actual.role === "value" && expected.role === "value";
+    if (actual.family !== "component" || expected.family !== "component")
+        return false;
+    for (const required of actual.requiredProperties) {
+        if (!expected.requiredProperties.has(required))
+            return false;
+    }
+    for (const [name, supplied] of expected.properties) {
+        const accepted = actual.properties.get(name);
+        if (!accepted || !assign(supplied, accepted))
+            return false;
+    }
+    const actualHandle = actual.arguments[0];
+    const expectedHandle = expected.arguments[0];
+    return !expectedHandle || !!actualHandle && assign(actualHandle, expectedHandle);
+}
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/websocket-runtime.d.ts

@@ -0,0 +1,2 @@
+export declare const VELAR_WEB_WEBSOCKET_RUNTIME: string;
+//# sourceMappingURL=websocket-runtime.d.ts.map

package/dist/websocket-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-runtime.d.ts","sourceRoot":"","sources":["../src/websocket-runtime.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,QA4B3B,CAAC"}

package/dist/websocket-runtime.js

@@ -0,0 +1,30 @@
+export const VELAR_WEB_WEBSOCKET_RUNTIME = String.raw `
+const __velarNativeWebSocket = globalThis.WebSocket;
+const __velarWebSocketConnections = new WeakMap();
+function __velarWsInteger(value, fallback, minimum, maximum, name) { if (value === undefined || value === null) return fallback; if (!Number.isSafeInteger(value) || value < minimum || value > maximum) throw new RangeError(name + " must be an integer from " + minimum + " through " + maximum); return value; }
+function __velarWsDuration(value, fallback) { if (value === undefined || value === null) return fallback; if (typeof value !== "string") throw new TypeError("WebSocket timeout must be Duration"); const match = /^([+-]?(?:\d+(?:\.\d+)?|\.\d+))(ms|s)$/.exec(value); if (!match) throw new TypeError("WebSocket timeout must be Duration such as 5s"); const result = Number(match[1]) * (match[2] === "s" ? 1000 : 1); if (!Number.isFinite(result) || result < 0 || result > 2147483647) throw new RangeError("WebSocket timeout is outside the supported range"); return result; }
+function __velarWsOptions(options = {}) { if (options === null || typeof options !== "object" || Array.isArray(options)) throw new TypeError("WebSocket options must be a record"); return { maxMessageBytes: __velarWsInteger(options.maxMessageBytes, 16 * 1024 * 1024, 1, 64 * 1024 * 1024, "maxMessageBytes"), maxQueuedMessages: __velarWsInteger(options.maxQueuedMessages, 256, 1, 10000, "maxQueuedMessages"), maxQueuedBytes: __velarWsInteger(options.maxQueuedBytes, 16 * 1024 * 1024, 1, 64 * 1024 * 1024, "maxQueuedBytes"), maxPendingSendBytes: __velarWsInteger(options.maxPendingSendBytes, 16 * 1024 * 1024, 1, 64 * 1024 * 1024, "maxPendingSendBytes") }; }
+function __velarWsUtf8(value) { return new TextEncoder().encode(value).byteLength; }
+function __velarWsBytes(value) { if (!(value instanceof Uint8Array)) return null; const output = new Uint8Array(value.byteLength); output.set(value); return output; }
+export class WebSocketBackpressureError extends Error { constructor(message = "WebSocket backpressure limit exceeded") { super(message); this.name = "WebSocketBackpressureError"; } }
+export class WebSocketClosedError extends Error { constructor(message = "WebSocket is closed") { super(message); this.name = "WebSocketClosedError"; } }
+export class WebSocketProtocolError extends Error { constructor(message = "WebSocket protocol error") { super(message); this.name = "WebSocketProtocolError"; } }
+export class WebSocketTimeoutError extends Error { constructor(message = "WebSocket timed out") { super(message); this.name = "WebSocketTimeoutError"; } }
+function __velarWsFinish(state) { if (state.finished) return; state.finished = true; if (state.waiter) { state.waiter.resolve(null); state.waiter = null; } }
+function __velarWsAbort(state) { state.finished = true; state.queue.length = 0; state.queuedBytes = 0; if (state.waiter) { state.waiter.resolve(null); state.waiter = null; } }
+function __velarWsRejectReceive(state, socket, code, reason) { __velarWsAbort(state); socket.close(code, reason); }
+function __velarWsWrap(socket, options) { const value = Object.create(__velarWsConnectionPrototype); const state = { socket, options, queue: [], queuedBytes: 0, waiter: null, finished: false, closePromise: null, sendWaiters: new Set() }; __velarWebSocketConnections.set(value, state); socket.binaryType = "arraybuffer";
+  socket.addEventListener("message", event => { if (state.finished) return; let message; let size; if (typeof event.data === "string") { size = __velarWsUtf8(event.data); if (size > options.maxMessageBytes) { __velarWsRejectReceive(state, socket, 4009, "Message too large"); return; } message = event.data; } else if (event.data instanceof ArrayBuffer) { size = event.data.byteLength; if (size > options.maxMessageBytes) { __velarWsRejectReceive(state, socket, 4009, "Message too large"); return; } message = new Uint8Array(event.data); } else { __velarWsRejectReceive(state, socket, 4003, "Unsupported message type"); return; } if (state.waiter) { const waiter = state.waiter; state.waiter = null; waiter.resolve(message); } else if (state.queue.length >= options.maxQueuedMessages || state.queuedBytes + size > options.maxQueuedBytes) __velarWsRejectReceive(state, socket, 4009, "Unread message queue full"); else { state.queue.push(message); state.queuedBytes += size; } });
+  socket.addEventListener("close", () => { __velarWsFinish(state); for (const reject of state.sendWaiters) reject(new WebSocketClosedError()); state.sendWaiters.clear(); }); socket.addEventListener("error", () => { if (state.waiter) { state.waiter.reject(new WebSocketProtocolError()); state.waiter = null; } __velarWsAbort(state); }); return Object.freeze(value); }
+const __velarWsConnectionPrototype = Object.freeze({
+  state() { const state = __velarWebSocketConnections.get(this); if (!state) throw new TypeError("WebSocket state requires a connection"); return state.socket.readyState === __velarNativeWebSocket.CONNECTING ? "connecting" : state.socket.readyState === __velarNativeWebSocket.OPEN ? "open" : state.socket.readyState === __velarNativeWebSocket.CLOSING ? "closing" : "closed"; },
+  send(message) { const state = __velarWebSocketConnections.get(this); if (!state) throw new TypeError("WebSocket.send requires a connection"); if (state.socket.readyState !== __velarNativeWebSocket.OPEN) return Promise.reject(new WebSocketClosedError()); const bytes = typeof message === "string" ? null : __velarWsBytes(message); if (bytes === null && typeof message !== "string") return Promise.reject(new TypeError("WebSocket.send requires text or Bytes")); const size = bytes?.byteLength ?? __velarWsUtf8(message); if (size > state.options.maxMessageBytes) return Promise.reject(new RangeError("WebSocket message exceeds maxMessageBytes")); if (state.socket.bufferedAmount + size > state.options.maxPendingSendBytes) return Promise.reject(new WebSocketBackpressureError()); state.socket.send(bytes ?? message); return new Promise((resolve, reject) => { state.sendWaiters.add(reject); const poll = () => { if (state.finished) { state.sendWaiters.delete(reject); reject(new WebSocketClosedError()); } else if (state.socket.bufferedAmount === 0) { state.sendWaiters.delete(reject); resolve(null); } else setTimeout(poll, 1); }; poll(); }); },
+  next() { const state = __velarWebSocketConnections.get(this); if (!state) throw new TypeError("WebSocket.next requires a connection"); if (state.queue.length) { const message = state.queue.shift(); state.queuedBytes -= typeof message === "string" ? __velarWsUtf8(message) : message.byteLength; return Promise.resolve(message); } if (state.finished) return Promise.resolve(null); if (state.waiter) return Promise.reject(new WebSocketBackpressureError("Only one WebSocket.next call may wait at a time")); return new Promise((resolve, reject) => { state.waiter = { resolve, reject }; }); },
+  close(code = 1000, reason = "") { const state = __velarWebSocketConnections.get(this); if (!state) throw new TypeError("WebSocket.close requires a connection"); if (!Number.isSafeInteger(code) || code < 1000 || code > 4999) return Promise.reject(new RangeError("WebSocket close code must be from 1000 through 4999")); if (typeof reason !== "string" || __velarWsUtf8(reason) > 123) return Promise.reject(new RangeError("WebSocket close reason cannot exceed 123 UTF-8 bytes")); if (state.finished) return Promise.resolve(null); if (!state.closePromise) { state.closePromise = new Promise(resolve => state.socket.addEventListener("close", () => resolve(null), { once: true })); state.socket.close(code, reason); } return state.closePromise; },
+});
+const __velarWsConnectionType = Object.freeze({ is(value) { return __velarWebSocketConnections.has(value); }, parse(value) { if (!this.is(value)) throw new TypeError("Value does not match WebSocketConnection"); return value; } });
+export const WebSocketConnection = __velarWsConnectionType; export const WebSocketServer = Object.freeze({ is() { return false; }, parse() { throw new TypeError("WebSocketServer is available only on Node"); } });
+export function connect(url, options = {}) { if (typeof __velarNativeWebSocket !== "function") return Promise.reject(new Error("The browser WebSocket API is unavailable")); if (typeof url !== "string" || !/^wss?:\/\//u.test(url)) return Promise.reject(new TypeError("WebSocket URL must start with ws:// or wss://")); const limits = __velarWsOptions(options); const timeout = __velarWsDuration(options.timeout, 10000); return new Promise((resolve, reject) => { const socket = new __velarNativeWebSocket(url); const timer = setTimeout(() => { socket.close(); reject(new WebSocketTimeoutError("WebSocket connection timed out")); }, timeout); socket.addEventListener("open", () => { clearTimeout(timer); resolve(__velarWsWrap(socket, limits)); }, { once: true }); socket.addEventListener("error", () => { clearTimeout(timer); reject(new WebSocketProtocolError("WebSocket connection failed")); }, { once: true }); }); }
+export function listen() { return Promise.reject(new Error("WebSocket.listen is available only on Node")); }
+`.trimStart();
+//# sourceMappingURL=websocket-runtime.js.map

package/dist/websocket-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-runtime.js","sourceRoot":"","sources":["../src/websocket-runtime.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,2BAA2B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BpD,CAAC,SAAS,EAAE,CAAC"}

package/dist/worker-runtime.d.ts

@@ -0,0 +1,2 @@
+export declare const VELAR_WEB_WORKER_RUNTIME: string;
+//# sourceMappingURL=worker-runtime.d.ts.map

package/dist/worker-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-runtime.d.ts","sourceRoot":"","sources":["../src/worker-runtime.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB,QAsExB,CAAC"}

package/dist/worker-runtime.js

@@ -0,0 +1,72 @@
+export const VELAR_WEB_WORKER_RUNTIME = String.raw `
+import { workerEntries as __velarWorkerEntries } from "velar/worker-manifest";
+import { Cancellation, CancellationError, TaskTimeoutError } from "velar/task";
+
+const __velarNativeWorker = globalThis.Worker;
+const __velarWorkerStates = new WeakMap();
+const __velarWorkerPoolStates = new WeakMap();
+let __velarWorkerServerInstalled = false;
+const __velarWorkerStructuredClone = globalThis.structuredClone;
+function __velarWorkerInteger(value, minimum, maximum, name) { if (!Number.isSafeInteger(value) || value < minimum || value > maximum) throw new RangeError(name + " must be an integer from " + minimum + " through " + maximum); return value; }
+function __velarWorkerRuntimeType(value, name) { if ((typeof value !== "object" && typeof value !== "function") || value === null || typeof value.parse !== "function" || typeof value.is !== "function") throw new TypeError(name + " must be a runtime Type"); return value; }
+function __velarWorkerDuration(value) { if (value === null) return 0; if (typeof value !== "string") throw new TypeError("Worker timeout must be Duration or null"); const match = /^([+-]?(?:\d+(?:\.\d+)?|\.\d+))(ms|s)$/.exec(value); if (!match) throw new TypeError("Worker timeout must be Duration such as 200ms or 2s"); const milliseconds = Number(match[1]) * (match[2] === "s" ? 1000 : 1); if (!Number.isFinite(milliseconds) || milliseconds < 0 || milliseconds > 2147483647) throw new RangeError("Worker timeout is outside the supported range"); return milliseconds; }
+function __velarWorkerTransfer(value) {
+  const transfers = []; const buffers = new Set(); const objects = new Set(); const pending = [{ value, depth: 0 }]; let visited = 0; let transferBytes = 0;
+  while (pending.length > 0 && visited < 10000 && transfers.length < 1024) {
+    const current = pending.pop(); const item = current.value; visited += 1;
+    if (item === null || (typeof item !== "object" && typeof item !== "function") || objects.has(item)) continue; objects.add(item);
+    if (ArrayBuffer.isView(item)) { const supported = item instanceof Uint8Array || item instanceof Uint16Array || item instanceof Uint32Array || item instanceof Float32Array; const buffer = item.buffer; if (supported && buffer instanceof ArrayBuffer && item.byteOffset === 0 && item.byteLength === buffer.byteLength && buffer.byteLength > 0 && transferBytes + buffer.byteLength <= 64 * 1024 * 1024 && !buffers.has(buffer)) { buffers.add(buffer); transfers.push(buffer); transferBytes += buffer.byteLength; } continue; }
+    if (current.depth >= 32) continue; const depth = current.depth + 1;
+    if (item instanceof Map) { for (const [key, nested] of item) pending.push({ value: key, depth }, { value: nested, depth }); continue; }
+    if (item instanceof Set) { for (const nested of item) pending.push({ value: nested, depth }); continue; }
+    for (const key of Object.keys(item)) pending.push({ value: item[key], depth });
+  }
+  return transfers;
+}
+function __velarWorkerOutbound(value) {
+  const sourceTransfers = __velarWorkerTransfer(value);
+  if (sourceTransfers.length === 0) return { value, transfers: sourceTransfers };
+  if (typeof __velarWorkerStructuredClone !== "function") throw new Error("The structured clone API is unavailable");
+  const snapshot = __velarWorkerStructuredClone(value);
+  return { value: snapshot, transfers: __velarWorkerTransfer(snapshot) };
+}
+function __velarWorkerFailure(error) { return { name: typeof error?.name === "string" ? error.name : "Error", message: typeof error?.message === "string" ? error.message : String(error), stack: typeof error?.stack === "string" ? error.stack : "" }; }
+export class WorkerBackpressureError extends Error { constructor(message = "Worker queue is full") { super(message); this.name = "WorkerBackpressureError"; } }
+export class WorkerCallError extends Error { constructor(message = "Worker call failed") { super(message); this.name = "WorkerCallError"; } }
+export class WorkerCrashedError extends Error { constructor(message = "Worker crashed") { super(message); this.name = "WorkerCrashedError"; } }
+export class WorkerClosedError extends Error { constructor(message = "Worker is closed") { super(message); this.name = "WorkerClosedError"; } }
+function __velarWorkerRejectAll(state, failure) { if (state.closed) return; state.closed = true; for (const pending of state.pending.values()) { if (pending.timer) clearTimeout(pending.timer); pending.unsubscribe(); pending.reject(failure); } state.pending.clear(); }
+const __velarWorkerPrototype = Object.freeze({
+  call(request, cancellation = null, timeout = null) {
+    const state = __velarWorkerStates.get(this); if (!state) throw new TypeError("Worker.call requires a Worker receiver"); if (state.closed) return Promise.reject(new WorkerClosedError());
+    if (state.pending.size >= state.capacity) return Promise.reject(new WorkerBackpressureError("Worker queue capacity " + state.capacity + " is full"));
+    if (cancellation !== null && !Cancellation.is(cancellation)) return Promise.reject(new TypeError("Worker cancellation must be Cancellation or null"));
+    let validated; try { validated = state.RequestType.parse(request); } catch (error) { return Promise.reject(error); }
+    let outbound; try { outbound = __velarWorkerOutbound(validated); } catch (error) { return Promise.reject(error); }
+    const milliseconds = __velarWorkerDuration(timeout); const id = state.nextId++;
+    return new Promise((resolve, reject) => { const pending = { resolve, reject, cancel: null, reason: "Worker call cancelled", timeout, timer: null, unsubscribe: () => null }; state.pending.set(id, pending); state.instance.postMessage({ kind: "call", id, value: outbound.value }, outbound.transfers); if (cancellation !== null) pending.unsubscribe = Cancellation.__velarOn(cancellation, reason => { if (!state.pending.has(id) || pending.cancel) return; pending.cancel = "cancel"; pending.reason = reason ?? pending.reason; state.instance.postMessage({ kind: "cancel", id, reason: pending.reason }); }); if (milliseconds > 0) pending.timer = setTimeout(() => { if (!state.pending.has(id) || pending.cancel) return; pending.cancel = "timeout"; state.instance.postMessage({ kind: "cancel", id, reason: "Worker call timed out" }); }, milliseconds); });
+  },
+  async close() { const state = __velarWorkerStates.get(this); if (!state) throw new TypeError("Worker.close requires a Worker receiver"); if (state.closed) return null; __velarWorkerRejectAll(state, new WorkerClosedError()); state.instance.terminate(); return null; },
+});
+function __velarWorkerClient(name, RequestType, ResponseType, capacity) {
+  if (typeof __velarNativeWorker !== "function") throw new Error("The browser Worker API is unavailable"); if (typeof name !== "string" || !Object.hasOwn(__velarWorkerEntries, name)) throw new RangeError("Unknown worker entry '" + String(name) + "'"); RequestType = __velarWorkerRuntimeType(RequestType, "Worker request Type"); ResponseType = __velarWorkerRuntimeType(ResponseType, "Worker response Type"); capacity = __velarWorkerInteger(capacity, 1, 10000, "Worker capacity");
+  const instance = new __velarNativeWorker(new URL("../" + __velarWorkerEntries[name], import.meta.url), { type: "module", name: "velar:" + name }); const value = Object.create(__velarWorkerPrototype); const state = { instance, RequestType, ResponseType, capacity, nextId: 1, pending: new Map(), closed: false }; __velarWorkerStates.set(value, state);
+  instance.addEventListener("message", event => { const message = event.data; if (!message || !Number.isSafeInteger(message.id)) { __velarWorkerRejectAll(state, new WorkerCrashedError("Worker returned an invalid message")); instance.terminate(); return; } const pending = state.pending.get(message.id); if (!pending) return; state.pending.delete(message.id); if (pending.timer) clearTimeout(pending.timer); pending.unsubscribe(); if (pending.cancel === "timeout") { pending.reject(new TaskTimeoutError("Worker call timed out after " + pending.timeout)); return; } if (pending.cancel === "cancel") { pending.reject(new CancellationError(pending.reason)); return; } if (!message.ok) { const remote = message.error ?? {}; const failure = new WorkerCallError((remote.name ? remote.name + ": " : "") + (remote.message ?? "Worker call failed")); if (typeof remote.stack === "string" && remote.stack) failure.stack += "\nRemote worker:\n" + remote.stack; pending.reject(failure); return; } try { pending.resolve(state.ResponseType.parse(message.value)); } catch (error) { pending.reject(error); } });
+  instance.addEventListener("error", event => __velarWorkerRejectAll(state, new WorkerCrashedError(event.message || "Worker crashed"))); instance.addEventListener("messageerror", () => __velarWorkerRejectAll(state, new WorkerCrashedError("Worker returned an unreadable message"))); return Object.freeze(value);
+}
+const __velarWorkerPoolPrototype = Object.freeze({
+  call(request, cancellation = null, timeout = null) { const state = __velarWorkerPoolStates.get(this); if (!state) throw new TypeError("WorkerPool.call requires a WorkerPool receiver"); if (state.closed) return Promise.reject(new WorkerClosedError("Worker pool is closed")); const total = state.workers.reduce((sum, item) => sum + __velarWorkerStates.get(item).pending.size, 0); if (total >= state.capacity) return Promise.reject(new WorkerBackpressureError("Worker pool queue capacity " + state.capacity + " is full")); let selected = state.workers[0]; for (const item of state.workers) if (__velarWorkerStates.get(item).pending.size < __velarWorkerStates.get(selected).pending.size) selected = item; return selected.call(request, cancellation, timeout); },
+  async close() { const state = __velarWorkerPoolStates.get(this); if (!state) throw new TypeError("WorkerPool.close requires a WorkerPool receiver"); if (state.closed) return null; state.closed = true; await Promise.all(state.workers.map(item => item.close())); return null; },
+});
+const __velarWorkerType = Object.freeze({ is(value) { return __velarWorkerStates.has(value); }, parse(value) { if (!this.is(value)) throw new TypeError("Value does not match Worker"); return value; } });
+const __velarWorkerPoolType = Object.freeze({ is(value) { return __velarWorkerPoolStates.has(value); }, parse(value) { if (!this.is(value)) throw new TypeError("Value does not match WorkerPool"); return value; } });
+export const Worker = Object.freeze({ ...__velarWorkerType, of() { return __velarWorkerType; } }); export const WorkerPool = Object.freeze({ ...__velarWorkerPoolType, of() { return __velarWorkerPoolType; } });
+export function worker(name, RequestType, ResponseType, capacity = 64) { return __velarWorkerClient(name, RequestType, ResponseType, capacity); }
+export function workerPool(name, RequestType, ResponseType, size, capacity = 256) { size = __velarWorkerInteger(size, 1, 32, "Worker pool size"); capacity = __velarWorkerInteger(capacity, size, 10000, "Worker pool capacity"); const workers = Array.from({ length: size }, () => __velarWorkerClient(name, RequestType, ResponseType, Math.ceil(capacity / size))); const value = Object.create(__velarWorkerPoolPrototype); __velarWorkerPoolStates.set(value, { workers, capacity, closed: false }); return Object.freeze(value); }
+export function serveWorker(RequestType, ResponseType, handler, capacity = 64) {
+  if (__velarWorkerServerInstalled) throw new Error("A worker entry may call serveWorker() only once"); RequestType = __velarWorkerRuntimeType(RequestType, "Worker request Type"); ResponseType = __velarWorkerRuntimeType(ResponseType, "Worker response Type"); if (typeof handler !== "function") throw new TypeError("serveWorker handler must be an async function"); capacity = __velarWorkerInteger(capacity, 1, 10000, "Worker capacity"); __velarWorkerServerInstalled = true;
+  const queue = []; const active = new Map(); let running = false; const drain = async () => { if (running) return; running = true; while (queue.length) { const message = queue.shift(); const cancellation = Cancellation.__velarCreate(); active.set(message.id, cancellation); try { const request = RequestType.parse(message.value); const result = ResponseType.parse(await handler(request, cancellation)); const outbound = __velarWorkerOutbound(result); globalThis.postMessage({ id: message.id, ok: true, value: outbound.value }, { transfer: outbound.transfers }); } catch (error) { globalThis.postMessage({ id: message.id, ok: false, error: __velarWorkerFailure(error) }); } finally { active.delete(message.id); } } running = false; };
+  globalThis.addEventListener("message", event => { const message = event.data; if (!message || !Number.isSafeInteger(message.id)) return; if (message.kind === "cancel") { const cancellation = active.get(message.id); if (cancellation) Cancellation.__velarCancel(cancellation, typeof message.reason === "string" ? message.reason : "Worker call cancelled"); else { const index = queue.findIndex(item => item.id === message.id); if (index >= 0) { queue.splice(index, 1); globalThis.postMessage({ id: message.id, ok: false, error: __velarWorkerFailure(new CancellationError(typeof message.reason === "string" ? message.reason : "Worker call cancelled")) }); } } return; } if (message.kind !== "call") return; if (queue.length + active.size >= capacity) { globalThis.postMessage({ id: message.id, ok: false, error: __velarWorkerFailure(new WorkerBackpressureError()) }); return; } queue.push(message); drain(); }); return null;
+}
+`.trimStart();
+//# sourceMappingURL=worker-runtime.js.map

package/dist/worker-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-runtime.js","sourceRoot":"","sources":["../src/worker-runtime.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,wBAAwB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsEjD,CAAC,SAAS,EAAE,CAAC"}