@moxxy/sdk 0.14.4 → 0.14.5

package/src/mode/project-messages.ts

@@ -61,6 +61,15 @@ export interface ProjectMessagesOptions {
   readonly systemPrompt?: string;
   /** Optional trailing user message — useful for plan-execute's "Focus on this step now: X". */
   readonly trailingUserText?: string;
+  /**
+   * Optional precomputed elision state for THIS exact log snapshot. When a
+   * caller already derived it within the same loop iteration (e.g. the
+   * compaction/elision gates), threading it here skips a redundant
+   * `computeElisionState` fold. MUST be the state of the same log — a stale one
+   * would mis-render stubs — so it is purely an opt-in fast path; omitting it
+   * recomputes (memoized on the log version), byte-identically.
+   */
+  readonly precomputedElisionState?: ElisionState;
 }
 
 interface CompactionRange {
@@ -260,7 +269,10 @@ export function projectMessages(
   const compactions = activeCompactionRanges(allEvents);
   const compactionFor = makeCompactionLookup(compactions);
   const emittedCompactions = new Set<CompactionRange>();
-  const el = computeElisionState(allEvents);
+  // Reuse a threaded state when the caller already derived it for this exact
+  // snapshot; otherwise `computeElisionState` is memoized on the log version so
+  // the in-iteration projection still folds only once.
+  const el = opts.precomputedElisionState ?? computeElisionState(allEvents);
 
   const messages: ProviderMessage[] = [];
   // The stable prefix is every message produced from events at/below the

package/src/package-root.test.ts

@@ -37,4 +37,41 @@ describe('@moxxy/sdk package root', () => {
 
     expect(check.issues[0]?.requirement.name).toBe('auth:provider:openai-codex');
   });
+
+  // The main barrel is the browser/RN-safe surface: a value import of any of
+  // these would drag a node:* builtin into a Metro/browser bundle. They live on
+  // the './server' subpath instead. This pins the split so a future accidental
+  // re-export on the main barrel is caught (see .dependency-cruiser.cjs
+  // `no-node-builtins-in-renderer`).
+  const NODE_ONLY_VALUE_EXPORTS = [
+    'spawnCliTunnel',
+    'isCliTunnelAvailable',
+    'writeFileAtomic',
+    'writeFileAtomicSync',
+    'moxxyHome',
+    'moxxyPath',
+    'readRequestBody',
+    'bearerTokenMatches',
+    'resolveChannelToken',
+    'rotateChannelToken',
+    'bearerGuard',
+    'encodeWsBearerProtocol',
+    'tokenFromWsProtocolHeader',
+    'MOXXY_WS_SUBPROTOCOL',
+    'MOXXY_WS_BEARER_PROTOCOL_PREFIX',
+  ] as const;
+
+  it('does NOT expose Node-runtime values on the browser/RN-safe main barrel', async () => {
+    const sdk: Record<string, unknown> = await import('@moxxy/sdk');
+    for (const name of NODE_ONLY_VALUE_EXPORTS) {
+      expect(sdk[name], `${name} must not be on the @moxxy/sdk main barrel`).toBeUndefined();
+    }
+  });
+
+  it('exposes the Node-runtime helpers on the @moxxy/sdk/server subpath', async () => {
+    const server: Record<string, unknown> = await import('@moxxy/sdk/server');
+    for (const name of NODE_ONLY_VALUE_EXPORTS) {
+      expect(server[name], `${name} must be exported from @moxxy/sdk/server`).toBeDefined();
+    }
+  });
 });

package/src/server.ts

@@ -0,0 +1,34 @@
+/**
+ * Node-runtime-only surface of @moxxy/sdk.
+ *
+ * Importing `@moxxy/sdk/server` pulls in the value helpers that statically
+ * depend on Node builtins (`node:child_process`, `node:fs`, `node:os`,
+ * `node:http`, `node:crypto`, `node:path`). The MAIN barrel (`@moxxy/sdk`) is
+ * deliberately kept free of these so a browser/React-Native bundle can value-
+ * import from it (and from `@moxxy/sdk/tool-display`) without dragging a Node
+ * builtin into the bundle — Metro cannot polyfill `node:child_process`.
+ *
+ * Node-side consumers (cli, runner, desktop-host, channel/oauth/webhooks
+ * plugins, …) import these helpers from here. The corresponding *type* exports
+ * (e.g. `TunnelHandle`, `WriteFileAtomicOptions`, `ChannelTokenOptions`) remain
+ * on the main barrel because types are erased at build time and never reach a
+ * bundle.
+ */
+
+export { spawnCliTunnel, isCliTunnelAvailable } from './tunnel.js';
+export {
+  writeFileAtomic,
+  writeFileAtomicSync,
+  moxxyHome,
+  moxxyPath,
+} from './fs-utils.js';
+export { readRequestBody, bearerTokenMatches } from './http-utils.js';
+export {
+  resolveChannelToken,
+  rotateChannelToken,
+  bearerGuard,
+  encodeWsBearerProtocol,
+  tokenFromWsProtocolHeader,
+  MOXXY_WS_SUBPROTOCOL,
+  MOXXY_WS_BEARER_PROTOCOL_PREFIX,
+} from './channel-auth.js';

package/src/transcriber.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from 'vitest';
+import { MOXXY_PCM16_24KHZ_MIME } from './transcriber.js';
+
+describe('MOXXY_PCM16_24KHZ_MIME', () => {
+  it('locks the cross-package wire value', () => {
+    // This is a PROTOCOL constant: the desktop/web capture path stamps it onto
+    // the audio blob and the Codex transcriber keys on it to wrap the raw PCM
+    // samples in a WAV header. Drift in the literal silently breaks
+    // transcription with no compile-time signal — so pin the exact bytes here.
+    expect(MOXXY_PCM16_24KHZ_MIME).toBe('audio/x-moxxy-pcm16-24khz');
+  });
+});

package/src/transcriber.ts

@@ -18,6 +18,20 @@
  *     used by models that advertise `supportsAudio: true`.
  */
 
+/**
+ * Wire MIME tag for raw 16-bit little-endian PCM mono at 24 kHz — the lossless
+ * format the desktop/web mic capture path produces and that the Codex
+ * transcriber keys on to wrap the bytes in a WAV header before upload.
+ *
+ * This is a cross-package PROTOCOL value: client-platform-web stamps it onto
+ * the captured blob, plugin-cli forwards it as the attachment `mimeType`, and
+ * plugin-stt-whisper switches on it. It lived as an independently-redeclared
+ * literal in all three (silent transcription breakage if any drifted), so it is
+ * hoisted here to the SDK's single zero-dep typed surface as the source of
+ * truth. Consumers should import this rather than re-spell the literal.
+ */
+export const MOXXY_PCM16_24KHZ_MIME = 'audio/x-moxxy-pcm16-24khz';
+
 export interface TranscriptionSegment {
   /** Segment start, in seconds from the start of the clip. */
   readonly start: number;