@soundscript/soundscript 0.1.13 → 0.1.15

package/project-transform/src/lsp/session.ts

@@ -0,0 +1,48 @@
+export interface OpenDocument {
+  languageId: string;
+  text: string;
+  uri: string;
+  version: number;
+}
+
+export class SessionState {
+  readonly #documents = new Map<string, OpenDocument>();
+  #revision = 0;
+
+  get(uri: string): OpenDocument | undefined {
+    return this.#documents.get(uri);
+  }
+
+  getAll(): readonly OpenDocument[] {
+    return [...this.#documents.values()];
+  }
+
+  revision(): number {
+    return this.#revision;
+  }
+
+  open(document: OpenDocument): void {
+    this.#documents.set(document.uri, document);
+    this.#revision += 1;
+  }
+
+  close(uri: string): void {
+    if (this.#documents.delete(uri)) {
+      this.#revision += 1;
+    }
+  }
+
+  update(uri: string, version: number, text: string): void {
+    const existing = this.#documents.get(uri);
+    if (!existing) {
+      return;
+    }
+
+    this.#documents.set(uri, {
+      ...existing,
+      text,
+      version,
+    });
+    this.#revision += 1;
+  }
+}

package/project-transform/src/lsp/timing.js

@@ -0,0 +1,43 @@
+import { runtimeEnv } from '../platform/host.js';
+const LSP_TIMING_ENV_VAR = 'SOUNDSCRIPT_LSP_TIMING';
+const DEFAULT_LSP_TIMING_THRESHOLD_MS = 25;
+export function isLspTimingEnabled(rawValue = runtimeEnv(LSP_TIMING_ENV_VAR)) {
+    return rawValue === '1' || rawValue === 'true';
+}
+function formatMetadata(metadata) {
+    return Object.entries(metadata)
+        .filter(([, value]) => value !== undefined)
+        .map(([key, value]) => `${key}=${String(value)}`)
+        .join(' ');
+}
+export function logLspTiming(operation, durationMs, metadata = {}, options = {}) {
+    const enabled = options.enabled ?? isLspTimingEnabled();
+    if (!enabled) {
+        return;
+    }
+    const thresholdMs = options.thresholdMs ?? DEFAULT_LSP_TIMING_THRESHOLD_MS;
+    if (!options.always && durationMs < thresholdMs) {
+        return;
+    }
+    const metadataText = formatMetadata(metadata);
+    const prefix = `[soundscript:lsp] ${operation} ${durationMs.toFixed(1)}ms`;
+    console.error(metadataText.length > 0 ? `${prefix} ${metadataText}` : prefix);
+}
+export function measureLspTiming(operation, metadata, fn, options = {}) {
+    const start = performance.now();
+    try {
+        return fn();
+    }
+    finally {
+        logLspTiming(operation, performance.now() - start, metadata, options);
+    }
+}
+export async function measureLspTimingAsync(operation, metadata, fn, options = {}) {
+    const start = performance.now();
+    try {
+        return await fn();
+    }
+    finally {
+        logLspTiming(operation, performance.now() - start, metadata, options);
+    }
+}

package/project-transform/src/lsp/timing.ts

@@ -0,0 +1,76 @@
+import { runtimeEnv } from '../platform/host.ts';
+
+const LSP_TIMING_ENV_VAR = 'SOUNDSCRIPT_LSP_TIMING';
+const DEFAULT_LSP_TIMING_THRESHOLD_MS = 25;
+
+export interface LspTimingMetadata {
+  [key: string]: boolean | number | string | undefined;
+}
+
+interface LspTimingOptions {
+  always?: boolean;
+  enabled?: boolean;
+  thresholdMs?: number;
+}
+
+export function isLspTimingEnabled(
+  rawValue = runtimeEnv(LSP_TIMING_ENV_VAR),
+): boolean {
+  return rawValue === '1' || rawValue === 'true';
+}
+
+function formatMetadata(metadata: LspTimingMetadata): string {
+  return Object.entries(metadata)
+    .filter(([, value]) => value !== undefined)
+    .map(([key, value]) => `${key}=${String(value)}`)
+    .join(' ');
+}
+
+export function logLspTiming(
+  operation: string,
+  durationMs: number,
+  metadata: LspTimingMetadata = {},
+  options: LspTimingOptions = {},
+): void {
+  const enabled = options.enabled ?? isLspTimingEnabled();
+  if (!enabled) {
+    return;
+  }
+
+  const thresholdMs = options.thresholdMs ?? DEFAULT_LSP_TIMING_THRESHOLD_MS;
+  if (!options.always && durationMs < thresholdMs) {
+    return;
+  }
+
+  const metadataText = formatMetadata(metadata);
+  const prefix = `[soundscript:lsp] ${operation} ${durationMs.toFixed(1)}ms`;
+  console.error(metadataText.length > 0 ? `${prefix} ${metadataText}` : prefix);
+}
+
+export function measureLspTiming<T>(
+  operation: string,
+  metadata: LspTimingMetadata,
+  fn: () => T,
+  options: LspTimingOptions = {},
+): T {
+  const start = performance.now();
+  try {
+    return fn();
+  } finally {
+    logLspTiming(operation, performance.now() - start, metadata, options);
+  }
+}
+
+export async function measureLspTimingAsync<T>(
+  operation: string,
+  metadata: LspTimingMetadata,
+  fn: () => Promise<T>,
+  options: LspTimingOptions = {},
+): Promise<T> {
+  const start = performance.now();
+  try {
+    return await fn();
+  } finally {
+    logLspTiming(operation, performance.now() - start, metadata, options);
+  }
+}

package/project-transform/src/lsp/transport.js

@@ -0,0 +1,205 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _AsyncMessageQueue_items, _AsyncMessageQueue_waiters, _MemoryClient_nextRequestId;
+import { runtimeStdinReadable, runtimeStdoutWritable } from '../platform/host.js';
+import { isJsonRpcNotification, isJsonRpcResponse } from './protocol.js';
+class AsyncMessageQueue {
+    constructor() {
+        _AsyncMessageQueue_items.set(this, []);
+        _AsyncMessageQueue_waiters.set(this, []);
+    }
+    push(message) {
+        const waiter = __classPrivateFieldGet(this, _AsyncMessageQueue_waiters, "f").shift();
+        if (waiter) {
+            waiter(message);
+            return;
+        }
+        __classPrivateFieldGet(this, _AsyncMessageQueue_items, "f").push(message);
+    }
+    shift() {
+        const message = __classPrivateFieldGet(this, _AsyncMessageQueue_items, "f").shift();
+        if (message !== undefined) {
+            return Promise.resolve(message);
+        }
+        return new Promise((resolve) => {
+            __classPrivateFieldGet(this, _AsyncMessageQueue_waiters, "f").push(resolve);
+        });
+    }
+}
+_AsyncMessageQueue_items = new WeakMap(), _AsyncMessageQueue_waiters = new WeakMap();
+class QueueTransport {
+    constructor(inbound, outbound) {
+        this.inbound = inbound;
+        this.outbound = outbound;
+    }
+    read() {
+        return this.inbound.shift();
+    }
+    write(message) {
+        this.outbound.push(message);
+        return Promise.resolve();
+    }
+}
+class MemoryClient {
+    constructor(requests, responses) {
+        this.requests = requests;
+        this.responses = responses;
+        _MemoryClient_nextRequestId.set(this, 1);
+    }
+    async readNotification(method) {
+        while (true) {
+            const message = await this.responses.shift();
+            if (message === null) {
+                throw new Error('Transport closed before notification was received.');
+            }
+            if (isJsonRpcNotification(message) && message.method === method) {
+                return message;
+            }
+        }
+    }
+    async readResponse(expectedId) {
+        while (true) {
+            const message = await this.responses.shift();
+            if (message === null) {
+                throw new Error('Transport closed before response was received.');
+            }
+            if (isJsonRpcResponse(message) && message.id === expectedId) {
+                return message;
+            }
+        }
+    }
+    sendNotification(method, params) {
+        this.requests.push({
+            jsonrpc: '2.0',
+            method,
+            params,
+        });
+        return Promise.resolve();
+    }
+    sendRequest(method, params) {
+        const id = __classPrivateFieldGet(this, _MemoryClient_nextRequestId, "f");
+        __classPrivateFieldSet(this, _MemoryClient_nextRequestId, __classPrivateFieldGet(this, _MemoryClient_nextRequestId, "f") + 1, "f");
+        this.requests.push({
+            jsonrpc: '2.0',
+            id,
+            method,
+            params,
+        });
+        return Promise.resolve(id);
+    }
+}
+_MemoryClient_nextRequestId = new WeakMap();
+async function readExactly(reader, length) {
+    const buffer = new Uint8Array(length);
+    let offset = 0;
+    while (offset < length) {
+        const bytesRead = await reader.read(buffer.subarray(offset));
+        if (bytesRead === null) {
+            return null;
+        }
+        offset += bytesRead;
+    }
+    return buffer;
+}
+async function readHeaders(reader) {
+    const bytes = [];
+    const singleByte = new Uint8Array(1);
+    while (true) {
+        const bytesRead = await reader.read(singleByte);
+        if (bytesRead === null) {
+            return bytes.length === 0 ? null : new TextDecoder().decode(new Uint8Array(bytes));
+        }
+        bytes.push(singleByte[0]);
+        const byteCount = bytes.length;
+        if (byteCount >= 4 &&
+            bytes[byteCount - 4] === 13 &&
+            bytes[byteCount - 3] === 10 &&
+            bytes[byteCount - 2] === 13 &&
+            bytes[byteCount - 1] === 10) {
+            return new TextDecoder().decode(new Uint8Array(bytes));
+        }
+    }
+}
+function createByteReader(readable) {
+    const reader = readable.getReader();
+    let buffered = new Uint8Array(0);
+    return {
+        async read(target) {
+            while (buffered.byteLength === 0) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    return null;
+                }
+                buffered = value ?? new Uint8Array(0);
+            }
+            const byteLength = Math.min(target.byteLength, buffered.byteLength);
+            target.set(buffered.subarray(0, byteLength));
+            buffered = buffered.subarray(byteLength);
+            return byteLength;
+        },
+    };
+}
+function createByteWriter(writable) {
+    const writer = writable.getWriter();
+    return {
+        async write(buffer) {
+            await writer.write(buffer);
+            return buffer.byteLength;
+        },
+    };
+}
+export function createMemoryTransportPair() {
+    const requests = new AsyncMessageQueue();
+    const responses = new AsyncMessageQueue();
+    return {
+        client: new MemoryClient(requests, responses),
+        server: new QueueTransport(requests, responses),
+    };
+}
+export function createStdioTransport(reader = createByteReader(runtimeStdinReadable()), writer = createByteWriter(runtimeStdoutWritable())) {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    let pendingWrite = Promise.resolve();
+    return {
+        async read() {
+            const headerText = await readHeaders(reader);
+            if (headerText === null) {
+                return null;
+            }
+            const contentLengthHeader = headerText
+                .split('\r\n')
+                .find((header) => header.toLowerCase().startsWith('content-length:'));
+            if (!contentLengthHeader) {
+                throw new Error('Missing Content-Length header.');
+            }
+            const contentLength = Number.parseInt(contentLengthHeader.split(':')[1]?.trim() ?? '', 10);
+            if (!Number.isFinite(contentLength) || contentLength < 0) {
+                throw new Error('Invalid Content-Length header.');
+            }
+            const payloadBytes = await readExactly(reader, contentLength);
+            if (payloadBytes === null) {
+                return null;
+            }
+            return JSON.parse(decoder.decode(payloadBytes));
+        },
+        async write(message) {
+            const writeOperation = pendingWrite.then(async () => {
+                const payload = encoder.encode(JSON.stringify(message));
+                const header = encoder.encode(`Content-Length: ${payload.byteLength}\r\n\r\n`);
+                await writer.write(header);
+                await writer.write(payload);
+            });
+            pendingWrite = writeOperation.catch(() => { });
+            await writeOperation;
+        },
+    };
+}

package/project-transform/src/lsp/transport.ts

@@ -0,0 +1,253 @@
+import { runtimeStdinReadable, runtimeStdoutWritable } from '../platform/host.ts';
+import { isJsonRpcNotification, isJsonRpcResponse, type JsonRpcMessage } from './protocol.ts';
+
+export interface MessageTransport {
+  read(): Promise<JsonRpcMessage | null>;
+  write(message: JsonRpcMessage): Promise<void>;
+}
+
+interface ByteReader {
+  read(buffer: Uint8Array): Promise<number | null>;
+}
+
+interface ByteWriter {
+  write(buffer: Uint8Array): Promise<number>;
+}
+
+class AsyncMessageQueue {
+  readonly #items: (JsonRpcMessage | null)[] = [];
+  readonly #waiters: ((message: JsonRpcMessage | null) => void)[] = [];
+
+  push(message: JsonRpcMessage | null): void {
+    const waiter = this.#waiters.shift();
+    if (waiter) {
+      waiter(message);
+      return;
+    }
+
+    this.#items.push(message);
+  }
+
+  shift(): Promise<JsonRpcMessage | null> {
+    const message = this.#items.shift();
+    if (message !== undefined) {
+      return Promise.resolve(message);
+    }
+
+    return new Promise((resolve) => {
+      this.#waiters.push(resolve);
+    });
+  }
+}
+
+class QueueTransport implements MessageTransport {
+  constructor(
+    private readonly inbound: AsyncMessageQueue,
+    private readonly outbound: AsyncMessageQueue,
+  ) {}
+
+  read(): Promise<JsonRpcMessage | null> {
+    return this.inbound.shift();
+  }
+
+  write(message: JsonRpcMessage): Promise<void> {
+    this.outbound.push(message);
+    return Promise.resolve();
+  }
+}
+
+class MemoryClient {
+  #nextRequestId = 1;
+
+  constructor(
+    private readonly requests: AsyncMessageQueue,
+    private readonly responses: AsyncMessageQueue,
+  ) {}
+
+  async readNotification(
+    method: string,
+  ): Promise<JsonRpcMessage & { method: string; params?: unknown }> {
+    while (true) {
+      const message = await this.responses.shift();
+      if (message === null) {
+        throw new Error('Transport closed before notification was received.');
+      }
+
+      if (isJsonRpcNotification(message) && message.method === method) {
+        return message;
+      }
+    }
+  }
+
+  async readResponse(
+    expectedId: number,
+  ): Promise<{ error?: unknown; id: number; result?: unknown }> {
+    while (true) {
+      const message = await this.responses.shift();
+      if (message === null) {
+        throw new Error('Transport closed before response was received.');
+      }
+
+      if (isJsonRpcResponse(message) && message.id === expectedId) {
+        return message;
+      }
+    }
+  }
+
+  sendNotification(method: string, params?: unknown): Promise<void> {
+    this.requests.push({
+      jsonrpc: '2.0',
+      method,
+      params,
+    });
+    return Promise.resolve();
+  }
+
+  sendRequest(method: string, params?: unknown): Promise<number> {
+    const id = this.#nextRequestId;
+    this.#nextRequestId += 1;
+
+    this.requests.push({
+      jsonrpc: '2.0',
+      id,
+      method,
+      params,
+    });
+
+    return Promise.resolve(id);
+  }
+}
+
+async function readExactly(reader: ByteReader, length: number): Promise<Uint8Array | null> {
+  const buffer = new Uint8Array(length);
+  let offset = 0;
+
+  while (offset < length) {
+    const bytesRead = await reader.read(buffer.subarray(offset));
+    if (bytesRead === null) {
+      return null;
+    }
+
+    offset += bytesRead;
+  }
+
+  return buffer;
+}
+
+async function readHeaders(reader: ByteReader): Promise<string | null> {
+  const bytes: number[] = [];
+  const singleByte = new Uint8Array(1);
+
+  while (true) {
+    const bytesRead = await reader.read(singleByte);
+    if (bytesRead === null) {
+      return bytes.length === 0 ? null : new TextDecoder().decode(new Uint8Array(bytes));
+    }
+
+    bytes.push(singleByte[0]);
+    const byteCount = bytes.length;
+    if (
+      byteCount >= 4 &&
+      bytes[byteCount - 4] === 13 &&
+      bytes[byteCount - 3] === 10 &&
+      bytes[byteCount - 2] === 13 &&
+      bytes[byteCount - 1] === 10
+    ) {
+      return new TextDecoder().decode(new Uint8Array(bytes));
+    }
+  }
+}
+
+function createByteReader(readable: ReadableStream<Uint8Array>): ByteReader {
+  const reader = readable.getReader();
+  let buffered: Uint8Array<ArrayBufferLike> = new Uint8Array(0);
+
+  return {
+    async read(target: Uint8Array): Promise<number | null> {
+      while (buffered.byteLength === 0) {
+        const { done, value } = await reader.read();
+        if (done) {
+          return null;
+        }
+        buffered = value ?? new Uint8Array(0);
+      }
+
+      const byteLength = Math.min(target.byteLength, buffered.byteLength);
+      target.set(buffered.subarray(0, byteLength));
+      buffered = buffered.subarray(byteLength);
+      return byteLength;
+    },
+  };
+}
+
+function createByteWriter(writable: WritableStream<Uint8Array>): ByteWriter {
+  const writer = writable.getWriter();
+
+  return {
+    async write(buffer: Uint8Array): Promise<number> {
+      await writer.write(buffer);
+      return buffer.byteLength;
+    },
+  };
+}
+
+export function createMemoryTransportPair(): {
+  client: MemoryClient;
+  server: MessageTransport;
+} {
+  const requests = new AsyncMessageQueue();
+  const responses = new AsyncMessageQueue();
+
+  return {
+    client: new MemoryClient(requests, responses),
+    server: new QueueTransport(requests, responses),
+  };
+}
+
+export function createStdioTransport(
+  reader: ByteReader = createByteReader(runtimeStdinReadable()),
+  writer: ByteWriter = createByteWriter(runtimeStdoutWritable()),
+): MessageTransport {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  let pendingWrite: Promise<void> = Promise.resolve();
+
+  return {
+    async read(): Promise<JsonRpcMessage | null> {
+      const headerText = await readHeaders(reader);
+      if (headerText === null) {
+        return null;
+      }
+
+      const contentLengthHeader = headerText
+        .split('\r\n')
+        .find((header) => header.toLowerCase().startsWith('content-length:'));
+      if (!contentLengthHeader) {
+        throw new Error('Missing Content-Length header.');
+      }
+
+      const contentLength = Number.parseInt(contentLengthHeader.split(':')[1]?.trim() ?? '', 10);
+      if (!Number.isFinite(contentLength) || contentLength < 0) {
+        throw new Error('Invalid Content-Length header.');
+      }
+
+      const payloadBytes = await readExactly(reader, contentLength);
+      if (payloadBytes === null) {
+        return null;
+      }
+
+      return JSON.parse(decoder.decode(payloadBytes)) as JsonRpcMessage;
+    },
+
+    async write(message: JsonRpcMessage): Promise<void> {
+      const writeOperation = pendingWrite.then(async () => {
+        const payload = encoder.encode(JSON.stringify(message));
+        const header = encoder.encode(`Content-Length: ${payload.byteLength}\r\n\r\n`);
+        await writer.write(header);
+        await writer.write(payload);
+      });
+      pendingWrite = writeOperation.catch(() => {});
+      await writeOperation;
+    },
+  };
+}

package/project-transform/src/lsp_main.js

@@ -0,0 +1,5 @@
+import { createServer } from './lsp/server.js';
+import { createStdioTransport } from './lsp/transport.js';
+const transport = createStdioTransport();
+const server = createServer(transport);
+await server.start();

package/project-transform/src/lsp_main.ts

@@ -0,0 +1,7 @@
+import { createServer } from './lsp/server.ts';
+import { createStdioTransport } from './lsp/transport.ts';
+
+const transport = createStdioTransport();
+const server = createServer(transport);
+
+await server.start();

package/project-transform/src/macros.d.ts

@@ -0,0 +1 @@
+export * from './public_macro_api/macro_api';

package/project-transform/src/macros.js

@@ -0,0 +1 @@
+export * from './frontend/macro_api.js';

package/project-transform/src/macros.ts

@@ -0,0 +1 @@
+export * from './frontend/macro_api.ts';

package/project-transform/src/main.js

@@ -0,0 +1,24 @@
+import { runCli } from './cli.js';
+import { parseCommand } from './config.js';
+import { runEditorDiagnosticsWorker } from './editor_diagnostics_worker.js';
+import { createServer } from './lsp/server.js';
+import { createStdioTransport } from './lsp/transport.js';
+import { runtimeArgs, runtimeCwd, runtimeExit, writeStdout } from './platform/host.js';
+async function main() {
+    const args = runtimeArgs();
+    const command = parseCommand(args, runtimeCwd());
+    if (command.kind === 'lsp') {
+        const transport = createStdioTransport();
+        const server = createServer(transport);
+        await server.start();
+        return;
+    }
+    if (command.kind === 'editor-worker') {
+        await runEditorDiagnosticsWorker();
+        return;
+    }
+    const result = await runCli(args);
+    writeStdout(result.output);
+    runtimeExit(result.exitCode);
+}
+await main();