@crowdedkingdoms/crowdyjs 8.22.0 → 10.0.0

package/dist/live-coding/lsp-protocol.d.ts

@@ -0,0 +1,98 @@
+export type JsonRpcId = number | string;
+export interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id: JsonRpcId;
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: JsonRpcId | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;
+export interface Position {
+    line: number;
+    character: number;
+}
+export interface Range {
+    start: Position;
+    end: Position;
+}
+export interface Location {
+    uri: string;
+    range: Range;
+}
+export interface TextDocumentIdentifier {
+    uri: string;
+}
+export interface VersionedTextDocumentIdentifier extends TextDocumentIdentifier {
+    version: number;
+}
+export interface TextDocumentItem extends VersionedTextDocumentIdentifier {
+    languageId: string;
+    text: string;
+}
+export interface TextDocumentContentChangeEvent {
+    range?: Range;
+    text: string;
+}
+export interface Diagnostic {
+    range: Range;
+    severity: 1 | 2 | 3 | 4;
+    source: 'crowdy-rust';
+    code: string;
+    message: string;
+}
+export interface CompletionItem {
+    label: string;
+    kind: number;
+    detail?: string;
+    documentation?: string;
+    insertText?: string;
+    sortText?: string;
+}
+export interface Hover {
+    contents: {
+        kind: 'markdown';
+        value: string;
+    };
+    range?: Range;
+}
+export interface DocumentSymbol {
+    name: string;
+    detail?: string;
+    kind: number;
+    range: Range;
+    selectionRange: Range;
+}
+export declare const JSON_RPC_ERRORS: {
+    readonly parseError: -32700;
+    readonly invalidRequest: -32600;
+    readonly methodNotFound: -32601;
+    readonly invalidParams: -32602;
+    readonly internalError: -32603;
+    readonly requestCancelled: -32800;
+    readonly contentModified: -32801;
+};
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function decodeJsonRpcMessage(value: unknown): {
+    ok: true;
+    message: JsonRpcMessage;
+} | {
+    ok: false;
+    code: number;
+    message: string;
+    id: JsonRpcId | null;
+};
+//# sourceMappingURL=lsp-protocol.d.ts.map

package/dist/live-coding/lsp-protocol.d.ts.map

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

package/dist/live-coding/lsp-protocol.js

@@ -0,0 +1,70 @@
+export const JSON_RPC_ERRORS = {
+    parseError: -32700,
+    invalidRequest: -32600,
+    methodNotFound: -32601,
+    invalidParams: -32602,
+    internalError: -32603,
+    requestCancelled: -32800,
+    contentModified: -32801,
+};
+export function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export function decodeJsonRpcMessage(value) {
+    let decoded = value;
+    if (typeof value === 'string') {
+        try {
+            decoded = JSON.parse(value);
+        }
+        catch {
+            return {
+                ok: false,
+                code: JSON_RPC_ERRORS.parseError,
+                message: 'Parse error',
+                id: null,
+            };
+        }
+    }
+    if (!isRecord(decoded) || decoded.jsonrpc !== '2.0') {
+        return {
+            ok: false,
+            code: JSON_RPC_ERRORS.invalidRequest,
+            message: 'Invalid Request',
+            id: null,
+        };
+    }
+    const hasId = Object.prototype.hasOwnProperty.call(decoded, 'id');
+    const id = typeof decoded.id === 'number' || typeof decoded.id === 'string'
+        ? decoded.id
+        : null;
+    if (typeof decoded.method === 'string') {
+        if (hasId && id === null) {
+            return {
+                ok: false,
+                code: JSON_RPC_ERRORS.invalidRequest,
+                message: 'Invalid Request',
+                id: null,
+            };
+        }
+        return {
+            ok: true,
+            message: {
+                jsonrpc: '2.0',
+                ...(id === null ? {} : { id }),
+                method: decoded.method,
+                ...('params' in decoded ? { params: decoded.params } : {}),
+            },
+        };
+    }
+    if (hasId &&
+        (id !== null || decoded.id === null) &&
+        ('result' in decoded || isRecord(decoded.error))) {
+        return { ok: true, message: decoded };
+    }
+    return {
+        ok: false,
+        code: JSON_RPC_ERRORS.invalidRequest,
+        message: 'Invalid Request',
+        id,
+    };
+}

package/dist/live-coding/monaco-services.d.ts

@@ -0,0 +1,22 @@
+export type MonacoServicesInitializer = () => Promise<void>;
+/**
+ * Process-wide one-shot gate for the monaco-vscode service collection.
+ * The upstream service registry is global and rejects a second initialize.
+ */
+export declare class MonacoServicesBootstrap {
+    private initialization;
+    ensure(initializer: MonacoServicesInitializer): Promise<void>;
+}
+export declare function ensureMonacoServicesInitialized(): Promise<void>;
+export interface MonacoWorkspaceLease {
+    uri: string;
+    release(): void;
+}
+/** Avoids Monaco's global model-URI collision across concurrent IDE mounts. */
+export declare class MonacoWorkspacePool {
+    private readonly active;
+    private nextSuffix;
+    acquire(): MonacoWorkspaceLease;
+}
+export declare function acquireMonacoWorkspace(): MonacoWorkspaceLease;
+//# sourceMappingURL=monaco-services.d.ts.map

package/dist/live-coding/monaco-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monaco-services.d.ts","sourceRoot":"","sources":["../../src/live-coding/monaco-services.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,yBAAyB,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AAE5D;;;GAGG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,cAAc,CAA8B;IAEpD,MAAM,CAAC,WAAW,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;CAI9D;AAID,wBAAgB,+BAA+B,IAAI,OAAO,CAAC,IAAI,CAAC,CAE/D;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,+EAA+E;AAC/E,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAC5C,OAAO,CAAC,UAAU,CAAK;IAEvB,OAAO,IAAI,oBAAoB;CAgBhC;AAID,wBAAgB,sBAAsB,IAAI,oBAAoB,CAE7D"}

package/dist/live-coding/monaco-services.js

@@ -0,0 +1,69 @@
+/**
+ * Process-wide one-shot gate for the monaco-vscode service collection.
+ * The upstream service registry is global and rejects a second initialize.
+ */
+export class MonacoServicesBootstrap {
+    constructor() {
+        this.initialization = null;
+    }
+    ensure(initializer) {
+        this.initialization ?? (this.initialization = Promise.resolve().then(initializer));
+        return this.initialization;
+    }
+}
+const defaultBootstrap = new MonacoServicesBootstrap();
+export function ensureMonacoServicesInitialized() {
+    return defaultBootstrap.ensure(initializeDefaultMonacoServices);
+}
+/** Avoids Monaco's global model-URI collision across concurrent IDE mounts. */
+export class MonacoWorkspacePool {
+    constructor() {
+        this.active = new Set();
+        this.nextSuffix = 2;
+    }
+    acquire() {
+        let uri = 'file:///player-mod';
+        while (this.active.has(uri)) {
+            uri = `file:///player-mod-${this.nextSuffix++}`;
+        }
+        this.active.add(uri);
+        let released = false;
+        return {
+            uri,
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                this.active.delete(uri);
+            },
+        };
+    }
+}
+const defaultWorkspacePool = new MonacoWorkspacePool();
+export function acquireMonacoWorkspace() {
+    return defaultWorkspacePool.acquire();
+}
+async function initializeDefaultMonacoServices() {
+    const [services, lifecycle] = await Promise.all([
+        import('@codingame/monaco-vscode-api/services'),
+        import('@codingame/monaco-vscode-api/lifecycle'),
+    ]);
+    if (lifecycle.servicesInitialized) {
+        await lifecycle.waitServicesReady();
+        return;
+    }
+    try {
+        // `initialize` supplies the package's base, environment, files, host,
+        // layout, extension and quick-access defaults. No workbench UI or language
+        // client override is needed for a configured standalone editor.
+        await services.initialize({}, document.body);
+    }
+    catch (error) {
+        // Cooperate with a host that won the initialization race.
+        if (lifecycle.servicesInitialized) {
+            await lifecycle.waitServicesReady();
+            return;
+        }
+        throw error;
+    }
+}

package/dist/live-coding/platform-index.d.ts

@@ -0,0 +1,29 @@
+export type PlatformSymbolKind = 'const' | 'enum' | 'field' | 'function' | 'macro' | 'method' | 'module' | 'reexport' | 'static' | 'struct' | 'trait' | 'type' | 'variant';
+export interface PlatformSymbol {
+    module: string;
+    name: string;
+    kind: PlatformSymbolKind;
+    signature: string;
+    docs: string;
+}
+export interface PlatformCrate {
+    name: string;
+    version: string;
+    sourceHash: string;
+}
+export interface PlatformIndex {
+    schemaVersion: 2;
+    rustVersion: string;
+    sdkVersion: string;
+    abiVersion: number;
+    contentHash: string;
+    crates: PlatformCrate[];
+    symbols: PlatformSymbol[];
+}
+export declare const MAX_PLATFORM_INDEX_BYTES: number;
+export declare const MAX_PLATFORM_CRATES = 256;
+export declare const MAX_PLATFORM_CRATE_FIELD_LENGTH = 256;
+export declare function loadPlatformIndex(input: unknown): PlatformIndex;
+export declare function computePlatformIndexContentHash(index: Pick<PlatformIndex, 'schemaVersion' | 'rustVersion' | 'sdkVersion' | 'abiVersion' | 'crates' | 'symbols'>): string;
+export declare const EMBEDDED_PLATFORM_INDEX: PlatformIndex;
+//# sourceMappingURL=platform-index.d.ts.map

package/dist/live-coding/platform-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-index.d.ts","sourceRoot":"","sources":["../../src/live-coding/platform-index.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,kBAAkB,GAC1B,OAAO,GACP,MAAM,GACN,OAAO,GACP,UAAU,GACV,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,MAAM,GACN,SAAS,CAAC;AAEd,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,kBAAkB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,CAAC,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,OAAO,EAAE,cAAc,EAAE,CAAC;CAC3B;AAiBD,eAAO,MAAM,wBAAwB,QAAkB,CAAC;AACxD,eAAO,MAAM,mBAAmB,MAAM,CAAC;AACvC,eAAO,MAAM,+BAA+B,MAAM,CAAC;AAmBnD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CAkE/D;AAED,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,IAAI,CACT,aAAa,EACX,eAAe,GACf,aAAa,GACb,YAAY,GACZ,YAAY,GACZ,QAAQ,GACR,SAAS,CACZ,GACA,MAAM,CAoBR;AA4LD,eAAO,MAAM,uBAAuB,EAAE,aAErC,CAAC"}

package/dist/live-coding/platform-index.js

@@ -0,0 +1,281 @@
+import { isRecord } from './lsp-protocol.js';
+import { GENERATED_BROWSER_AUTHORING_INDEX } from './browser-authoring-index.generated.js';
+const SYMBOL_KINDS = new Set([
+    'const',
+    'enum',
+    'field',
+    'function',
+    'macro',
+    'method',
+    'module',
+    'reexport',
+    'static',
+    'struct',
+    'trait',
+    'type',
+    'variant',
+]);
+export const MAX_PLATFORM_INDEX_BYTES = 2 * 1024 * 1024;
+export const MAX_PLATFORM_CRATES = 256;
+export const MAX_PLATFORM_CRATE_FIELD_LENGTH = 256;
+const INDEX_KEYS = new Set([
+    'schemaVersion',
+    'rustVersion',
+    'sdkVersion',
+    'abiVersion',
+    'contentHash',
+    'crates',
+    'symbols',
+]);
+const CRATE_KEYS = new Set(['name', 'version', 'sourceHash']);
+const SYMBOL_KEYS = new Set([
+    'module',
+    'name',
+    'kind',
+    'signature',
+    'docs',
+]);
+export function loadPlatformIndex(input) {
+    assertSerializedSize(input);
+    if (!isRecord(input))
+        throw new Error('Platform index must be an object');
+    assertExactKeys(input, INDEX_KEYS, 'platform index');
+    if (input.schemaVersion !== 2) {
+        throw new Error(`Unsupported platform index schemaVersion: ${String(input.schemaVersion)}`);
+    }
+    const rustVersion = requiredString(input.rustVersion, 'rustVersion');
+    const sdkVersion = requiredString(input.sdkVersion, 'sdkVersion');
+    if (!Number.isSafeInteger(input.abiVersion) || input.abiVersion < 0) {
+        throw new Error('abiVersion must be a non-negative safe integer');
+    }
+    const abiVersion = input.abiVersion;
+    const contentHash = requiredString(input.contentHash, 'contentHash');
+    if (!/^[a-f0-9]{64}$/u.test(contentHash)) {
+        throw new Error('contentHash must be a lowercase SHA-256 hex digest');
+    }
+    if (!Array.isArray(input.crates) || input.crates.length === 0) {
+        throw new Error('crates must be a non-empty array');
+    }
+    if (input.crates.length > MAX_PLATFORM_CRATES) {
+        throw new Error(`Platform index exceeds the ${MAX_PLATFORM_CRATES} crate limit`);
+    }
+    const crates = input.crates.map((entry, index) => loadCrate(entry, index));
+    const crateNames = new Set();
+    for (const crate of crates) {
+        if (crateNames.has(crate.name)) {
+            throw new Error(`Duplicate platform crate: ${crate.name}`);
+        }
+        crateNames.add(crate.name);
+    }
+    if (!Array.isArray(input.symbols)) {
+        throw new Error('symbols must be an array');
+    }
+    if (input.symbols.length > 20000) {
+        throw new Error('Platform index exceeds the 20,000 symbol limit');
+    }
+    const symbols = input.symbols.map((entry, index) => loadSymbol(entry, index));
+    const seen = new Set();
+    for (const symbol of symbols) {
+        const path = `${symbol.module}::${symbol.name}`;
+        const key = `${path}\0${symbol.kind}\0${symbol.signature}`;
+        if (seen.has(key))
+            throw new Error(`Duplicate platform symbol: ${path}`);
+        seen.add(key);
+    }
+    const loaded = {
+        schemaVersion: 2,
+        rustVersion,
+        sdkVersion,
+        abiVersion,
+        contentHash,
+        crates: Object.freeze(crates),
+        symbols: Object.freeze(symbols),
+    };
+    const computedHash = computePlatformIndexContentHash(loaded);
+    if (computedHash !== contentHash) {
+        throw new Error(`Platform index contentHash mismatch: expected ${contentHash}, computed ${computedHash}`);
+    }
+    assertSerializedSize(loaded);
+    return Object.freeze(loaded);
+}
+export function computePlatformIndexContentHash(index) {
+    const payload = {
+        schemaVersion: index.schemaVersion,
+        rustVersion: index.rustVersion,
+        sdkVersion: index.sdkVersion,
+        abiVersion: index.abiVersion,
+        crates: index.crates.map((crate) => ({
+            name: crate.name,
+            version: crate.version,
+            sourceHash: crate.sourceHash,
+        })),
+        symbols: index.symbols.map((symbol) => ({
+            module: symbol.module,
+            name: symbol.name,
+            kind: symbol.kind,
+            signature: symbol.signature,
+            docs: symbol.docs,
+        })),
+    };
+    return sha256Hex(JSON.stringify(payload));
+}
+function loadCrate(input, index) {
+    if (!isRecord(input))
+        throw new Error(`crates[${index}] must be an object`);
+    assertExactKeys(input, CRATE_KEYS, `crates[${index}]`);
+    const sourceHash = requiredString(input.sourceHash, `crates[${index}].sourceHash`);
+    if (!/^[a-f0-9]{64}$/u.test(sourceHash)) {
+        throw new Error(`crates[${index}].sourceHash must be a lowercase SHA-256 hex digest`);
+    }
+    return Object.freeze({
+        name: requiredCrateString(input.name, `crates[${index}].name`),
+        version: requiredCrateString(input.version, `crates[${index}].version`),
+        sourceHash,
+    });
+}
+function loadSymbol(input, index) {
+    if (!isRecord(input))
+        throw new Error(`symbols[${index}] must be an object`);
+    assertExactKeys(input, SYMBOL_KEYS, `symbols[${index}]`);
+    const kind = requiredString(input.kind, `symbols[${index}].kind`);
+    if (!SYMBOL_KINDS.has(kind)) {
+        throw new Error(`symbols[${index}].kind is unsupported`);
+    }
+    const symbol = {
+        module: requiredString(input.module, `symbols[${index}].module`),
+        name: requiredString(input.name, `symbols[${index}].name`),
+        kind: kind,
+        signature: requiredString(input.signature, `symbols[${index}].signature`),
+        docs: boundedString(input.docs, `symbols[${index}].docs`),
+    };
+    return Object.freeze(symbol);
+}
+function requiredString(value, field) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > 16384) {
+        throw new Error(`${field} must be a non-empty bounded string`);
+    }
+    return value;
+}
+function requiredCrateString(value, field) {
+    if (typeof value !== 'string' ||
+        value.length === 0 ||
+        value.length > MAX_PLATFORM_CRATE_FIELD_LENGTH) {
+        throw new Error(`${field} must be a non-empty string of at most ${MAX_PLATFORM_CRATE_FIELD_LENGTH} characters`);
+    }
+    return value;
+}
+function boundedString(value, field) {
+    if (typeof value !== 'string' || value.length > 16384) {
+        throw new Error(`${field} must be a bounded string`);
+    }
+    return value;
+}
+function assertExactKeys(input, allowed, field) {
+    const unexpected = Object.keys(input).find((key) => !allowed.has(key));
+    if (unexpected)
+        throw new Error(`${field} has unexpected field ${unexpected}`);
+    const missing = [...allowed].find((key) => !(key in input));
+    if (missing)
+        throw new Error(`${field} is missing ${missing}`);
+}
+function assertSerializedSize(input) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(input);
+    }
+    catch {
+        throw new Error('Platform index must be JSON-serializable');
+    }
+    if (serialized === undefined)
+        return;
+    const bytes = new TextEncoder().encode(serialized).byteLength;
+    if (bytes > MAX_PLATFORM_INDEX_BYTES) {
+        throw new Error(`Platform index is ${bytes} bytes; limit is ${MAX_PLATFORM_INDEX_BYTES}`);
+    }
+}
+function sha256Hex(value) {
+    const input = new TextEncoder().encode(value);
+    const paddedLength = Math.ceil((input.length + 9) / 64) * 64;
+    const padded = new Uint8Array(paddedLength);
+    padded.set(input);
+    padded[input.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    const bitLength = input.length * 8;
+    view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296));
+    view.setUint32(paddedLength - 4, bitLength >>> 0);
+    const state = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const words = new Uint32Array(64);
+    for (let offset = 0; offset < padded.length; offset += 64) {
+        for (let index = 0; index < 16; index++) {
+            words[index] = view.getUint32(offset + index * 4);
+        }
+        for (let index = 16; index < 64; index++) {
+            const left = words[index - 15];
+            const right = words[index - 2];
+            const sigma0 = rotateRight(left, 7) ^ rotateRight(left, 18) ^ (left >>> 3);
+            const sigma1 = rotateRight(right, 17) ^ rotateRight(right, 19) ^ (right >>> 10);
+            words[index] =
+                (words[index - 16] + sigma0 + words[index - 7] + sigma1) >>> 0;
+        }
+        let a = state[0];
+        let b = state[1];
+        let c = state[2];
+        let d = state[3];
+        let e = state[4];
+        let f = state[5];
+        let g = state[6];
+        let h = state[7];
+        for (let index = 0; index < 64; index++) {
+            const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+            const choice = (e & f) ^ (~e & g);
+            const temporary1 = (h + sum1 + choice + SHA256_CONSTANTS[index] + words[index]) >>> 0;
+            const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+            const majority = (a & b) ^ (a & c) ^ (b & c);
+            const temporary2 = (sum0 + majority) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + temporary1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (temporary1 + temporary2) >>> 0;
+        }
+        state[0] = (state[0] + a) >>> 0;
+        state[1] = (state[1] + b) >>> 0;
+        state[2] = (state[2] + c) >>> 0;
+        state[3] = (state[3] + d) >>> 0;
+        state[4] = (state[4] + e) >>> 0;
+        state[5] = (state[5] + f) >>> 0;
+        state[6] = (state[6] + g) >>> 0;
+        state[7] = (state[7] + h) >>> 0;
+    }
+    return [...state]
+        .map((word) => word.toString(16).padStart(8, '0'))
+        .join('');
+}
+function rotateRight(value, bits) {
+    return (value >>> bits) | (value << (32 - bits));
+}
+const SHA256_CONSTANTS = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+    0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+    0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+    0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+    0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+    0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+export const EMBEDDED_PLATFORM_INDEX = loadPlatformIndex(GENERATED_BROWSER_AUTHORING_INDEX);

package/dist/live-coding/rust-analysis.d.ts

@@ -0,0 +1,24 @@
+import type { CompletionItem, Diagnostic, DocumentSymbol, Hover, Location, Position } from './lsp-protocol.js';
+import type { PlatformIndex } from './platform-index.js';
+import type { VirtualDocument } from './vfs.js';
+export declare class RustAnalysis {
+    private readonly parser;
+    private readonly platformIndex;
+    private readonly cache;
+    private constructor();
+    static create(options: {
+        parserWasmUrl: string;
+        grammarWasmUrl: string;
+        platformIndex: PlatformIndex;
+    }): Promise<RustAnalysis>;
+    diagnostics(document: VirtualDocument): Diagnostic[];
+    completions(document: VirtualDocument, position: Position, workspace: readonly VirtualDocument[]): CompletionItem[];
+    hover(document: VirtualDocument, position: Position, workspace: readonly VirtualDocument[]): Hover | null;
+    documentSymbols(document: VirtualDocument): DocumentSymbol[];
+    definition(document: VirtualDocument, position: Position, workspace: readonly VirtualDocument[]): Location | null;
+    invalidate(uri: string): void;
+    dispose(): void;
+    private workspaceSymbols;
+    private analyze;
+}
+//# sourceMappingURL=rust-analysis.d.ts.map

package/dist/live-coding/rust-analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rust-analysis.d.ts","sourceRoot":"","sources":["../../src/live-coding/rust-analysis.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,cAAc,EACd,UAAU,EACV,cAAc,EACd,KAAK,EACL,QAAQ,EACR,QAAQ,EAET,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAEV,aAAa,EAGd,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAsHhD,qBAAa,YAAY;IAIrB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAJhC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuC;IAE7D,OAAO;WAKM,MAAM,CAAC,OAAO,EAAE;QAC3B,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC;QACvB,aAAa,EAAE,aAAa,CAAC;KAC9B,GAAG,OAAO,CAAC,YAAY,CAAC;IAWzB,WAAW,CAAC,QAAQ,EAAE,eAAe,GAAG,UAAU,EAAE;IAIpD,WAAW,CACT,QAAQ,EAAE,eAAe,EACzB,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,SAAS,eAAe,EAAE,GACpC,cAAc,EAAE;IAoCnB,KAAK,CACH,QAAQ,EAAE,eAAe,EACzB,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,SAAS,eAAe,EAAE,GACpC,KAAK,GAAG,IAAI;IAwCf,eAAe,CAAC,QAAQ,EAAE,eAAe,GAAG,cAAc,EAAE;IAU5D,UAAU,CACR,QAAQ,EAAE,eAAe,EACzB,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,SAAS,eAAe,EAAE,GACpC,QAAQ,GAAG,IAAI;IAWlB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAI7B,OAAO,IAAI,IAAI;IAKf,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,OAAO;CA6ChB"}