@nimbus-sh/core 0.6.0 → 0.7.0

package/src/runtime/javascript-ast.ts

@@ -1,4 +1,4 @@
-import { parse, type AnyNode } from 'acorn';
+import { parse, tokenizer, tokTypes, type AnyNode, type TokenType } from 'acorn';
 
 export type AstNode = AnyNode & Record<string, unknown>;
 
@@ -11,18 +11,49 @@ export function parseJavaScriptModule(source: string): AstNode {
 }
 
 export function hasTopLevelModuleSyntax(source: string): boolean {
-  let ast: AstNode;
   try {
-    ast = parseJavaScriptModule(source);
+    const tokens = tokenizer(source, {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+      allowHashBang: true,
+    });
+    let braceDepth = 0;
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    let previous: TokenType | undefined;
+
+    const updateDepth = (type: TokenType): void => {
+      if (type === tokTypes.braceL || type === tokTypes.dollarBraceL) braceDepth++;
+      else if (type === tokTypes.braceR) braceDepth = Math.max(0, braceDepth - 1);
+      else if (type === tokTypes.parenL) parenDepth++;
+      else if (type === tokTypes.parenR) parenDepth = Math.max(0, parenDepth - 1);
+      else if (type === tokTypes.bracketL) bracketDepth++;
+      else if (type === tokTypes.bracketR) bracketDepth = Math.max(0, bracketDepth - 1);
+    };
+
+    while (true) {
+      const token = tokens.getToken();
+      const type = token.type;
+      if (type === tokTypes.eof) return false;
+      const topLevel = braceDepth === 0 && parenDepth === 0 && bracketDepth === 0;
+
+      if (topLevel && previous !== tokTypes.dot) {
+        if (type === tokTypes._export) return true;
+        if (type === tokTypes._import) {
+          const next = tokens.getToken();
+          if (next.type !== tokTypes.parenL && next.type !== tokTypes.dot) return true;
+          updateDepth(next.type);
+          previous = next.type;
+          continue;
+        }
+      }
+
+      updateDepth(type);
+      previous = type;
+    }
   } catch {
     return false;
   }
-  return nodeList(ast, 'body').some((node) =>
-    node.type === 'ImportDeclaration' ||
-    node.type === 'ExportNamedDeclaration' ||
-    node.type === 'ExportDefaultDeclaration' ||
-    node.type === 'ExportAllDeclaration'
-  );
 }
 
 export function nodeList(node: AstNode, key: string): AstNode[] {

package/src/runtime/opentui-wasm-backend.ts

@@ -211,18 +211,17 @@ export class OpenTUIWasmBackend {
    * semantics), so each `dlopen`'d symbol call frees what was allocated before
    * it. Without this a per-frame `rgbaPtr(color)` would leak linear memory.
    *
-   * `view` is the source ArrayBufferView when the caller passed a writable one:
-   * native FFI `ptr(view)` yields a live pointer into the view's storage, so
-   * after the symbol call the view must reflect anything Zig wrote into it. Many
-   * FFIRenderLib wrappers materialize OUT-buffers this way — `getCursorState`,
-   * `getTerminalCapabilities`, `getRenderStats`, the span-feed's
-   * `streamDrainSpans(ptr(outBuffer))`, every `editBufferGet*`/`editorViewGet*` —
-   * so the claimed-scratch release copies these back before freeing.
+   * `view` is a writable byte view over the caller's original storage.
+   * Native `ptr(value)` exposes live memory for both ArrayBuffer and typed-array
+   * inputs, so every transient allocation copies back after the symbol call.
+   * OpenTUI's struct getters use bare ArrayBuffers (`LogicalCursorStruct`,
+   * `VisualCursorStruct`, stats, terminal capabilities), while span-feed drains
+   * use typed arrays. Both forms must observe Zig's writes.
    */
   readonly #pendingPtrScratch: Array<{
     offset: number;
     size: number;
-    view: ArrayBufferView | null;
+    view: ArrayBufferView;
   }> = [];
 
   /**
@@ -336,12 +335,10 @@ export class OpenTUIWasmBackend {
   // allocation as transient scratch that the next symbol call frees (see
   // `#bindSymbol`). This keeps a per-frame `rgbaPtr(color)` loop leak-free.
   //
-  // A writable ArrayBufferView is also an OUT-buffer here: native `ptr(view)` is
-  // a live pointer into the view's storage, so after the call the view must
-  // reflect Zig's writes. We record the source view so the claimed-scratch
-  // release copies it back (the span-feed `streamDrainSpans(ptr(drainBuffer))`
-  // and every FFIRenderLib `ptr(outBuffer)`/`ptr(cursorBuffer)`/`ptr(statsBuffer)`
-  // getter depend on this). Read-only ArrayBuffers carry a null view (copy-in only).
+  // Every ArrayBuffer and ArrayBufferView is potentially an OUT-buffer:
+  // native `ptr(value)` is a live pointer into the same storage. Copy the
+  // arena bytes back after the call so bare struct buffers and typed-array
+  // windows have identical semantics.
   ptr(value: ArrayBuffer | ArrayBufferView): OpenTUIPointer {
     const { bytes, byteOffset, byteLength } = viewBytes(value);
     const size = byteLength === 0 ? ARENA_ALIGN : byteLength;
@@ -352,7 +349,7 @@ export class OpenTUIWasmBackend {
     this.#pendingPtrScratch.push({
       offset,
       size,
-      view: ArrayBuffer.isView(value) ? value : null,
+      view: ArrayBuffer.isView(value) ? value : new Uint8Array(value),
     });
     return offset;
   }
@@ -513,8 +510,13 @@ export class OpenTUIWasmBackend {
         for (const s of scratch) scratchBytes += s.size;
         diag.rec(name, this.#exports.memory.buffer.byteLength - memBefore, marshaled, scratchBytes);
       }
-      if (returns === 'u64' || returns === 'i64') {
-        return typeof result === 'bigint' ? result : BigInt(result as number);
+      if (returns === 'u64') {
+        const value = typeof result === 'bigint' ? result : BigInt(result as number);
+        return BigInt.asUintN(64, value);
+      }
+      if (returns === 'i64') {
+        const value = typeof result === 'bigint' ? result : BigInt(result as number);
+        return BigInt.asIntN(64, value);
       }
       return result;
     };

package/src/runtime/port-registry.ts

@@ -23,8 +23,9 @@
  *   `request.method` and application headers mirror the outer request,
  *   Nimbus credentials/internal headers are removed, and
  *   `request.body` is a ReadableStream (or null for GET/HEAD) that
- *   the facet can consume once. The returned Response is returned
- *   to the outer fetch as-is; its body is streamed directly.
+ *   the facet can consume once. The returned Response is streamed
+ *   straight back, with one normalization: the hop speaks identity,
+ *   so a compressed body is decoded here. See `decodeContentCoding`.
  */
 
 import { sanitizeUntrustedHeaders } from '../_shared/untrusted-request.js';
@@ -48,7 +49,60 @@ export interface PortEntry {
   capability: string;
 }
 
-function createPortCapability(): string {
+/**
+ * Content codings this hop can undo. `DecompressionStream` decodes exactly
+ * these; brotli and zstd have no decoder in the runtime, so a body in one of
+ * those cannot be repaired here.
+ */
+const DECODABLE_CONTENT_CODINGS = new Map<string, 'gzip' | 'deflate'>([
+  ['gzip', 'gzip'],
+  ['x-gzip', 'gzip'],
+  ['deflate', 'deflate'],
+]);
+
+/**
+ * Hand back a port target's response with its bytes and its headers in
+ * agreement.
+ *
+ * A `Response` a facet builds always holds an identity body. The runtime
+ * treats the bytes a `Response` is constructed from as unencoded and runs its
+ * own content negotiation on the way out: it drops a `Content-Encoding` the
+ * client did not ask for, and compresses again when the client did. Either
+ * way a guest server's `Content-Encoding` is a label with nothing behind it,
+ * and the browser renders compressed bytes as text.
+ *
+ * The forwarded request asks the target for `identity`, so this decode covers
+ * the server that compresses whatever the client said. A coding with no
+ * decoder answers 502: an honest failure beats a page of mojibake.
+ */
+function decodeContentCoding(response: Response, port: number): Response {
+  const coding = response.headers.get('Content-Encoding')?.trim().toLowerCase();
+  if (!coding || coding === 'identity' || response.body === null) return response;
+
+  const format = DECODABLE_CONTENT_CODINGS.get(coding);
+  if (!format) {
+    void response.body.cancel().catch(() => {});
+    return new Response(
+      JSON.stringify({
+        error: `port proxy: target answered Content-Encoding "${coding}", which this hop cannot decode`,
+        port,
+      }),
+      { status: 502, headers: { 'Content-Type': 'application/json' } },
+    );
+  }
+
+  const headers = new Headers(response.headers);
+  headers.delete('Content-Encoding');
+  // The decoded body has a different length; the Response re-derives it.
+  headers.delete('Content-Length');
+  return new Response(response.body.pipeThrough(new DecompressionStream(format)), {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+}
+
+export function createPortCapability(): string {
   const bytes = crypto.getRandomValues(new Uint8Array(12));
   return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
 }
@@ -262,6 +316,10 @@ export class PortRegistry {
       if (authorization) headers.set('authorization', authorization);
 
       headers.set('X-Nimbus-Port', String(port));
+      // A Response cannot carry an encoded body across this hop, so the
+      // target is asked for the one coding that survives it. See
+      // `decodeContentCoding` for the server that compresses anyway.
+      headers.set('Accept-Encoding', 'identity');
       // `duplex: 'half'` is required by workerd when body is a
       // ReadableStream — otherwise `new Request(…)` throws. It's not
       // part of the published @cloudflare/workers-types RequestInit,
@@ -305,12 +363,12 @@ export class PortRegistry {
         );
       }
 
-      // Return the facet's Response as-is. Body is streamed; headers,
-      // status, and status-text pass through unchanged. We do NOT
-      // inject Access-Control-Allow-Origin — a port proxy forwards
-      // whatever CORS policy the user's HTTP server chose (audit C3
+      // Stream the facet's Response back. Status, status-text, and every
+      // header pass through; only a content coding the hop cannot carry is
+      // undone. We do NOT inject Access-Control-Allow-Origin — a port proxy
+      // forwards whatever CORS policy the user's HTTP server chose (audit C3
       // discourages gratuitous wildcards on non-static routes).
-      return response;
+      return decodeContentCoding(response, port);
     } catch (error: unknown) {
       // Server-side triage — users see only the 502 body, operators
       // see the full error + stack in Worker logs.

package/src/shell/stdin-adapter.ts

@@ -0,0 +1,58 @@
+import type { CommandInputStream } from '../substrate/lifo/commands/types.js';
+
+/**
+ * One consuming source behind the full reader contract, byte-accurate:
+ * the text is encoded once and every offset is a byte offset, so
+ * readBytes(1) over `é` yields exactly one UTF-8 byte per call and mixed
+ * text/byte consumption never diverges. Worker pure-builtin adapters hold
+ * stdin as a plain string; without this they can only offer readAll, and
+ * streaming commands see an empty pipe.
+ */
+export function staticStdinReader(text: string): CommandInputStream {
+  const bytes = new TextEncoder().encode(text);
+  const decoder = new TextDecoder('utf-8');
+  let offset = 0;
+
+  const pull = (max: number): Uint8Array | null => {
+    if (offset >= bytes.length) return null;
+    const end = Math.min(offset + max, bytes.length);
+    const chunk = bytes.subarray(offset, end);
+    offset = end;
+    return chunk;
+  };
+
+  return {
+    readBytes: async (maxLength: number) => {
+      if (maxLength <= 0) return new Uint8Array(0);
+      return pull(maxLength);
+    },
+    read: async () => {
+      while (offset < bytes.length) {
+        const end = Math.min(offset + 65536, bytes.length);
+        const text2 = decoder.decode(bytes.subarray(offset, end), { stream: true });
+        offset = end;
+        if (text2.length > 0) return text2;
+      }
+      const tail = decoder.decode();
+      return tail.length > 0 ? tail : null;
+    },
+    readAll: async () => {
+      if (offset >= bytes.length) return '';
+      const out = decoder.decode(bytes.subarray(offset));
+      offset = bytes.length;
+      return out;
+    },
+    readLine: async () => {
+      if (offset >= bytes.length) return null;
+      const newline = bytes.indexOf(0x0a, offset);
+      if (newline === -1) {
+        const line = decoder.decode(bytes.subarray(offset));
+        offset = bytes.length;
+        return line;
+      }
+      const line = decoder.decode(bytes.subarray(offset, newline));
+      offset = newline + 1;
+      return line;
+    },
+  };
+}