@crowdedkingdoms/crowdyjs 8.22.0 → 9.0.0

package/dist/live-coding/vfs.js

@@ -0,0 +1,174 @@
+export const DEFAULT_VFS_LIMITS = {
+    maxFiles: 32,
+    maxFileBytes: 256 * 1024,
+    maxWorkspaceBytes: 1024 * 1024,
+};
+export class VfsLimitError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 'VFS_LIMIT';
+        this.name = 'VfsLimitError';
+    }
+}
+export class VirtualFileSystem {
+    constructor(workspaceUri = 'file:///player-mod', limits = {}) {
+        this.files = new Map();
+        this.encoder = new TextEncoder();
+        this.totalBytes = 0;
+        this.workspaceUri = workspaceUri.replace(/\/+$/, '');
+        const root = new URL(this.workspaceUri);
+        if (root.protocol !== 'file:' ||
+            root.search ||
+            root.hash ||
+            !root.pathname.startsWith('/') ||
+            root.pathname === '/') {
+            throw new Error('workspaceUri must be a non-root file URI');
+        }
+        this.limits = { ...DEFAULT_VFS_LIMITS, ...limits };
+        this.assertLimits();
+    }
+    get size() {
+        return this.files.size;
+    }
+    get bytes() {
+        return this.totalBytes;
+    }
+    open(item) {
+        const path = this.pathForUri(item.uri);
+        const previous = this.files.get(item.uri);
+        if (!previous && this.files.size >= this.limits.maxFiles) {
+            throw new VfsLimitError(`Workspace file limit is ${this.limits.maxFiles}`);
+        }
+        if (previous && item.version <= previous.version) {
+            return previous;
+        }
+        const next = this.makeDocument(item, path);
+        this.ensureFits(next.bytes, previous?.bytes ?? 0);
+        if (previous)
+            this.totalBytes -= previous.bytes;
+        this.files.set(item.uri, next);
+        this.totalBytes += next.bytes;
+        return next;
+    }
+    change(uri, version, changes) {
+        const previous = this.require(uri);
+        if (version <= previous.version) {
+            return { applied: false, document: previous };
+        }
+        let text = previous.text;
+        for (const change of changes) {
+            if (!change.range) {
+                text = change.text;
+                continue;
+            }
+            const start = offsetAt(text, change.range.start);
+            const end = offsetAt(text, change.range.end);
+            if (end < start)
+                throw new Error('Invalid content change range');
+            text = text.slice(0, start) + change.text + text.slice(end);
+        }
+        const next = this.makeDocument({
+            uri,
+            version,
+            languageId: previous.languageId,
+            text,
+        }, previous.path);
+        this.ensureFits(next.bytes, previous.bytes);
+        this.files.set(uri, next);
+        this.totalBytes += next.bytes - previous.bytes;
+        return { applied: true, document: next };
+    }
+    close(uri) {
+        const previous = this.files.get(uri);
+        if (!previous)
+            return false;
+        this.files.delete(uri);
+        this.totalBytes -= previous.bytes;
+        return true;
+    }
+    get(uri) {
+        return this.files.get(uri);
+    }
+    require(uri) {
+        const document = this.files.get(uri);
+        if (!document)
+            throw new Error(`Document is not open: ${uri}`);
+        return document;
+    }
+    documents() {
+        return [...this.files.values()];
+    }
+    clear() {
+        this.files.clear();
+        this.totalBytes = 0;
+    }
+    pathForUri(uri) {
+        let parsed;
+        try {
+            parsed = new URL(uri);
+        }
+        catch {
+            throw new Error(`Invalid document URI: ${uri}`);
+        }
+        if (parsed.protocol !== 'file:' ||
+            parsed.search ||
+            parsed.hash ||
+            !uri.startsWith(`${this.workspaceUri}/`)) {
+            throw new Error(`Document is outside ${this.workspaceUri}`);
+        }
+        const relative = decodeURIComponent(parsed.pathname.slice(new URL(this.workspaceUri).pathname.length + 1));
+        if (relative.length === 0 ||
+            relative.startsWith('/') ||
+            relative.split('/').some((part) => part === '' || part === '..' || part === '.')) {
+            throw new Error(`Unsafe document path: ${relative}`);
+        }
+        return relative;
+    }
+    makeDocument(item, path) {
+        if (!Number.isSafeInteger(item.version) || item.version < 0) {
+            throw new Error('Document version must be a non-negative safe integer');
+        }
+        const bytes = this.encoder.encode(item.text).byteLength;
+        if (bytes > this.limits.maxFileBytes) {
+            throw new VfsLimitError(`${path} is ${bytes} bytes; file limit is ${this.limits.maxFileBytes}`);
+        }
+        return Object.freeze({ ...item, path, bytes });
+    }
+    ensureFits(nextBytes, replacedBytes) {
+        const total = this.totalBytes - replacedBytes + nextBytes;
+        if (total > this.limits.maxWorkspaceBytes) {
+            throw new VfsLimitError(`Workspace is ${total} bytes; limit is ${this.limits.maxWorkspaceBytes}`);
+        }
+    }
+    assertLimits() {
+        for (const [name, value] of Object.entries(this.limits)) {
+            if (!Number.isSafeInteger(value) || value <= 0) {
+                throw new Error(`${name} must be a positive safe integer`);
+            }
+        }
+        if (this.limits.maxFileBytes > this.limits.maxWorkspaceBytes) {
+            throw new Error('maxFileBytes cannot exceed maxWorkspaceBytes');
+        }
+    }
+}
+export function offsetAt(text, position) {
+    if (!Number.isSafeInteger(position.line) ||
+        !Number.isSafeInteger(position.character) ||
+        position.line < 0 ||
+        position.character < 0) {
+        throw new Error('Invalid document position');
+    }
+    let offset = 0;
+    for (let line = 0; line < position.line; line++) {
+        const newline = text.indexOf('\n', offset);
+        if (newline < 0)
+            throw new Error('Document position is outside the text');
+        offset = newline + 1;
+    }
+    const newline = text.indexOf('\n', offset);
+    const lineEnd = newline < 0 ? text.length : newline;
+    const target = offset + position.character;
+    if (target > lineEnd)
+        throw new Error('Document position is outside the text');
+    return target;
+}

package/dist/live-coding/worker-transport.d.ts

@@ -0,0 +1,60 @@
+import { AbstractMessageReader, AbstractMessageWriter, type DataCallback, type Disposable, type Message } from 'vscode-jsonrpc';
+import { type JsonRpcMessage } from './lsp-protocol.js';
+export type { Disposable };
+export interface LanguageWorkerLike {
+    postMessage(message: unknown): void;
+    addEventListener(type: 'message' | 'error' | 'messageerror', listener: EventListener): void;
+    removeEventListener(type: 'message' | 'error' | 'messageerror', listener: EventListener): void;
+    terminate(): void;
+}
+/** Standard vscode-jsonrpc MessageReader over structured-clone worker messages. */
+export declare class WorkerMessageReader extends AbstractMessageReader {
+    private readonly worker;
+    private callback;
+    private listening;
+    constructor(worker: LanguageWorkerLike);
+    listen(callback: DataCallback): Disposable;
+    dispose(): void;
+    private readonly onMessage;
+    private readonly onMessageError;
+    private readonly onWorkerError;
+}
+/** Standard vscode-jsonrpc MessageWriter over structured-clone worker messages. */
+export declare class WorkerMessageWriter extends AbstractMessageWriter {
+    private readonly worker;
+    private disposed;
+    private errorCount;
+    constructor(worker: LanguageWorkerLike);
+    write(message: Message): Promise<void>;
+    end(): void;
+    dispose(): void;
+}
+export interface WorkerLanguageClientOptions {
+    requestTimeoutMs?: number;
+}
+/**
+ * LSP 3.17 JSON-RPC client over a real vscode-jsonrpc MessageConnection.
+ * Monaco providers adapt editor calls to this connection; transport framing,
+ * request ids, cancellation, errors, and notifications are standard JSON-RPC.
+ */
+export declare class WorkerLanguageClient {
+    private readonly worker;
+    private readonly options;
+    private readonly reader;
+    private readonly writer;
+    private readonly connection;
+    private readonly transportErrorHandlers;
+    private readonly readerErrorDisposable;
+    private disposed;
+    private terminateTimer;
+    constructor(worker: LanguageWorkerLike, options?: WorkerLanguageClientOptions);
+    initialize(params: unknown): Promise<unknown>;
+    request(method: string, params?: unknown): Promise<unknown>;
+    notify(method: string, params?: unknown): Promise<void>;
+    onNotification(method: string, callback: (params: unknown) => void): Disposable;
+    shutdown(): void;
+    dispose(): void;
+}
+export declare function createDefaultRustLanguageWorker(): Worker;
+export declare function isWorkerLspMessage(value: unknown): value is JsonRpcMessage;
+//# sourceMappingURL=worker-transport.d.ts.map

package/dist/live-coding/worker-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-transport.d.ts","sourceRoot":"","sources":["../../src/live-coding/worker-transport.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EAErB,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,OAAO,EACb,MAAM,gBAAgB,CAAC;AASxB,OAAO,EAEL,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EAAE,UAAU,EAAE,CAAC;AAE3B,MAAM,WAAW,kBAAkB;IACjC,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACpC,gBAAgB,CACd,IAAI,EAAE,SAAS,GAAG,OAAO,GAAG,cAAc,EAC1C,QAAQ,EAAE,aAAa,GACtB,IAAI,CAAC;IACR,mBAAmB,CACjB,IAAI,EAAE,SAAS,GAAG,OAAO,GAAG,cAAc,EAC1C,QAAQ,EAAE,aAAa,GACtB,IAAI,CAAC;IACR,SAAS,IAAI,IAAI,CAAC;CACnB;AAED,mFAAmF;AACnF,qBAAa,mBAAoB,SAAQ,qBAAqB;IAIhD,OAAO,CAAC,QAAQ,CAAC,MAAM;IAHnC,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,SAAS,CAAS;gBAEG,MAAM,EAAE,kBAAkB;IAIvD,MAAM,CAAC,QAAQ,EAAE,YAAY,GAAG,UAAU;IAUjC,OAAO,IAAI,IAAI;IAWxB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAOxB;IAEF,OAAO,CAAC,QAAQ,CAAC,cAAc,CAE7B;IAEF,OAAO,CAAC,QAAQ,CAAC,aAAa,CAM5B;CACH;AAED,mFAAmF;AACnF,qBAAa,mBAAoB,SAAQ,qBAAqB;IAIhD,OAAO,CAAC,QAAQ,CAAC,MAAM;IAHnC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,UAAU,CAAK;gBAEM,MAAM,EAAE,kBAAkB;IAIvD,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAYtC,GAAG,IAAI,IAAI;IAIF,OAAO,IAAI,IAAI;CAIzB;AAED,MAAM,WAAW,2BAA2B;IAC1C,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;GAIG;AACH,qBAAa,oBAAoB;IAU7B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAV1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqB;IAChD,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAqC;IAC5E,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAa;IACnD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,cAAc,CAA8C;gBAGjD,MAAM,EAAE,kBAAkB,EAC1B,OAAO,GAAE,2BAAgC;IAWtD,UAAU,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAMnD,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAsD3D,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAKvD,cAAc,CACZ,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,GAClC,UAAU;IAIb,QAAQ,IAAI,IAAI;IAehB,OAAO,IAAI,IAAI;CAYhB;AAED,wBAAgB,+BAA+B,IAAI,MAAM,CAKxD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAE1E"}

package/dist/live-coding/worker-transport.js

@@ -0,0 +1,204 @@
+import { AbstractMessageReader, AbstractMessageWriter, CancellationTokenSource, } from 'vscode-jsonrpc';
+import { ExitNotification, InitializeRequest, InitializedNotification, ShutdownRequest, createProtocolConnection, } from 'vscode-languageserver-protocol';
+import { decodeJsonRpcMessage, } from './lsp-protocol.js';
+/** Standard vscode-jsonrpc MessageReader over structured-clone worker messages. */
+export class WorkerMessageReader extends AbstractMessageReader {
+    constructor(worker) {
+        super();
+        this.worker = worker;
+        this.callback = null;
+        this.listening = false;
+        this.onMessage = (event) => {
+            const decoded = decodeJsonRpcMessage(event.data);
+            if (!decoded.ok) {
+                this.fireError(new Error(decoded.message));
+                return;
+            }
+            this.callback?.(decoded.message);
+        };
+        this.onMessageError = () => {
+            this.fireError(new Error('Language worker sent an unreadable message'));
+        };
+        this.onWorkerError = (event) => {
+            const message = 'message' in event && typeof event.message === 'string'
+                ? event.message
+                : 'Language worker failed';
+            this.fireError(new Error(message));
+        };
+    }
+    listen(callback) {
+        if (this.listening)
+            throw new Error('WorkerMessageReader is already listening');
+        this.listening = true;
+        this.callback = callback;
+        this.worker.addEventListener('message', this.onMessage);
+        this.worker.addEventListener('messageerror', this.onMessageError);
+        this.worker.addEventListener('error', this.onWorkerError);
+        return { dispose: () => this.dispose() };
+    }
+    dispose() {
+        if (this.listening) {
+            this.worker.removeEventListener('message', this.onMessage);
+            this.worker.removeEventListener('messageerror', this.onMessageError);
+            this.worker.removeEventListener('error', this.onWorkerError);
+        }
+        this.listening = false;
+        this.callback = null;
+        super.dispose();
+    }
+}
+/** Standard vscode-jsonrpc MessageWriter over structured-clone worker messages. */
+export class WorkerMessageWriter extends AbstractMessageWriter {
+    constructor(worker) {
+        super();
+        this.worker = worker;
+        this.disposed = false;
+        this.errorCount = 0;
+    }
+    write(message) {
+        if (this.disposed)
+            return Promise.reject(new Error('Worker writer is disposed'));
+        try {
+            this.worker.postMessage(message);
+            return Promise.resolve();
+        }
+        catch (error) {
+            this.errorCount++;
+            this.fireError(error, message, this.errorCount);
+            return Promise.reject(error);
+        }
+    }
+    end() {
+        this.dispose();
+    }
+    dispose() {
+        this.disposed = true;
+        super.dispose();
+    }
+}
+/**
+ * LSP 3.17 JSON-RPC client over a real vscode-jsonrpc MessageConnection.
+ * Monaco providers adapt editor calls to this connection; transport framing,
+ * request ids, cancellation, errors, and notifications are standard JSON-RPC.
+ */
+export class WorkerLanguageClient {
+    constructor(worker, options = {}) {
+        this.worker = worker;
+        this.options = options;
+        this.transportErrorHandlers = new Set();
+        this.disposed = false;
+        this.terminateTimer = null;
+        this.reader = new WorkerMessageReader(worker);
+        this.writer = new WorkerMessageWriter(worker);
+        this.readerErrorDisposable = this.reader.onError((error) => {
+            for (const handler of this.transportErrorHandlers)
+                handler(error);
+        });
+        this.connection = createProtocolConnection(this.reader, this.writer);
+        this.connection.listen();
+    }
+    async initialize(params) {
+        const result = await this.request(InitializeRequest.type.method, params);
+        await this.notify(InitializedNotification.type.method, {});
+        return result;
+    }
+    request(method, params) {
+        if (this.disposed)
+            return Promise.reject(new Error('Language client is disposed'));
+        const cancellation = new CancellationTokenSource();
+        const timeoutMs = this.options.requestTimeoutMs ?? 3000;
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const onTransportError = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                cancellation.cancel();
+                cancellation.dispose();
+                this.transportErrorHandlers.delete(onTransportError);
+                reject(error);
+            };
+            const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                cancellation.cancel();
+                cancellation.dispose();
+                this.transportErrorHandlers.delete(onTransportError);
+                reject(new Error(`Language request timed out: ${method}`));
+            }, timeoutMs);
+            this.transportErrorHandlers.add(onTransportError);
+            const request = params === undefined
+                ? this.connection.sendRequest(method, cancellation.token)
+                : this.connection.sendRequest(method, params, cancellation.token);
+            void request
+                .then((value) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                cancellation.dispose();
+                this.transportErrorHandlers.delete(onTransportError);
+                resolve(value);
+            }, (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                cancellation.dispose();
+                this.transportErrorHandlers.delete(onTransportError);
+                reject(error instanceof Error
+                    ? error
+                    : new Error('Language request failed'));
+            });
+        });
+    }
+    notify(method, params) {
+        if (this.disposed)
+            return Promise.reject(new Error('Language client is disposed'));
+        return this.connection.sendNotification(method, params);
+    }
+    onNotification(method, callback) {
+        return this.connection.onNotification(method, callback);
+    }
+    shutdown() {
+        if (this.disposed || this.terminateTimer)
+            return;
+        const finish = () => {
+            if (this.disposed)
+                return;
+            void this.connection
+                .sendNotification(ExitNotification.type.method)
+                .catch(() => { })
+                .finally(() => this.dispose());
+        };
+        void this.request(ShutdownRequest.type.method)
+            .catch(() => { })
+            .finally(finish);
+        this.terminateTimer = setTimeout(finish, this.options.requestTimeoutMs ?? 3000);
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        if (this.terminateTimer)
+            clearTimeout(this.terminateTimer);
+        this.terminateTimer = null;
+        this.transportErrorHandlers.clear();
+        this.readerErrorDisposable.dispose();
+        this.connection.dispose();
+        this.reader.dispose();
+        this.writer.dispose();
+        this.worker.terminate();
+    }
+}
+export function createDefaultRustLanguageWorker() {
+    return new Worker(new URL('./rust-lsp.worker.js', import.meta.url), {
+        type: 'module',
+        name: 'crowdy-rust-lsp',
+    });
+}
+export function isWorkerLspMessage(value) {
+    return decodeJsonRpcMessage(value).ok;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@crowdedkingdoms/crowdyjs",
-  "version": "8.22.0",
-  "description": "Client SDK for Crowded Kingdoms GraphQL API with UDP proxy support",
+  "version": "9.0.0",
+  "description": "Browser-first Crowded Kingdoms SDK with GraphQL, realtime, and local Rust authoring support",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,6 +17,10 @@
     "./stores": {
       "import": "./dist/stores/index.js",
       "types": "./dist/stores/index.d.ts"
+    },
+    "./live-coding": {
+      "import": "./dist/live-coding/index.js",
+      "types": "./dist/live-coding/index.d.ts"
     }
   },
   "sideEffects": false,
@@ -33,7 +37,10 @@
     "codegen": "graphql-codegen --config codegen.ts",
     "check:schema": "npm run codegen && git diff --exit-code schema.gql src/generated/graphql.ts",
     "codegen:watch": "graphql-codegen --config codegen.ts --watch",
-    "build": "tsc",
+    "authoring-index:generate": "node scripts/generate-browser-authoring-index.mjs --write",
+    "authoring-index:drift": "node scripts/sync-browser-authoring-index.mjs",
+    "check:authoring-index": "node scripts/validate-browser-authoring-index.mjs && node scripts/generate-browser-authoring-index.mjs",
+    "build": "npm run check:authoring-index && tsc && node scripts/copy-live-coding-assets.mjs",
     "test": "npm run build && node --test --test-concurrency=1 test/unit/*.test.mjs test/e2e/*.test.mjs",
     "test:unit": "npm run build && node --test test/unit/*.test.mjs",
     "test:e2e": "npm run build && node --test --test-concurrency=1 test/e2e/*.test.mjs",
@@ -50,7 +57,9 @@
     "graphql",
     "game-api",
     "multiplayer",
-    "sdk"
+    "sdk",
+    "rust",
+    "webassembly"
   ],
   "author": "",
   "license": "MIT",
@@ -73,13 +82,16 @@
     "ws": "^8.21.1"
   },
   "dependencies": {
+    "@codingame/monaco-vscode-api": "25.1.2",
     "@codingame/monaco-vscode-editor-api": "25.1.2",
     "@graphql-typed-document-node/core": "^3.2.0",
+    "@vscode/tree-sitter-wasm": "0.3.1",
     "dompurify": "3.4.12",
     "graphql": "^16.13.2",
     "graphql-ws": "^6.0.8",
-    "monaco-languageclient": "10.7.0",
-    "vscode-ws-jsonrpc": "3.5.0"
+    "vscode-jsonrpc": "8.2.0",
+    "vscode-languageserver-protocol": "3.17.5",
+    "web-tree-sitter": "0.26.11"
   },
   "overrides": {
     "dompurify": "$dompurify"