@forgeax/engine-remote 0.1.4 → 0.1.6

package/src/server.ts

@@ -46,8 +46,8 @@ export type StartServerOptions = {
   readonly profiler?: unknown;
   /** Structural report provider; remote never imports the App owner. */
   readonly execution?: unknown;
-  /** Host-owned dynamic module resolver; omitted for package-neutral eval. */
-  readonly importModule?: (specifier: string) => Promise<unknown>;
+  /** Read-only World-owned simulation inspection root. */
+  readonly simulation?: unknown;
   /**
    * Host-owned RHI capture capability for eval-scope injection (plan-strategy D-4).
    * It is exposed as the single `rhiCapture` eval root.
@@ -75,13 +75,14 @@ type JsonRpcResponse = {
 } & ({ result: unknown } | { error: JsonRpcError });
 
 function inspectorErrorToJsonRpc(e: RemoteError): JsonRpcError {
+  const detail = (e as unknown as { detail?: unknown }).detail;
   const data: Record<string, unknown> = {
     code: e.code,
     expected: e.expected,
     hint: e.hint,
     message: e.message,
   };
-  if (e.detail !== undefined) data.detail = e.detail;
+  if (detail !== undefined) data.detail = detail;
   return {
     code: REMOTE_TO_JSONRPC[e.code],
     message: REMOTE_ERROR_MESSAGES[e.code],
@@ -106,47 +107,6 @@ function respondOk(id: number | string | null, result: unknown): JsonRpcResponse
   return { jsonrpc: '2.0', id, result };
 }
 
-type EvalResultShape = 'bigint' | 'cyclic-object' | 'unsupported';
-
-const EVAL_RESULT_NOT_SERIALIZABLE_EXPECTED = 'eval result is JSON-serializable';
-const EVAL_RESULT_NOT_SERIALIZABLE_HINT =
-  'return a JSON-safe value; BigInt and cyclic objects are unsupported over JSON-RPC';
-
-function classifyEvalResultShape(value: unknown): EvalResultShape {
-  if (typeof value === 'bigint') return 'bigint';
-  if (value !== null && typeof value === 'object') return 'cyclic-object';
-  return 'unsupported';
-}
-
-function serializeResponse(response: JsonRpcResponse): string {
-  try {
-    const serialized = JSON.stringify(response);
-    if (serialized !== undefined) return serialized;
-  } catch {
-    // A successful eval result can be a valid JavaScript value that JSON-RPC
-    // cannot carry. Convert that transport-only failure below.
-  }
-
-  if (!('result' in response)) {
-    return JSON.stringify(respondError(response.id, -32603, 'Internal error')) as string;
-  }
-
-  const error = new RemoteError({
-    code: 'eval-result-not-serializable',
-    expected: EVAL_RESULT_NOT_SERIALIZABLE_EXPECTED,
-    hint: EVAL_RESULT_NOT_SERIALIZABLE_HINT,
-    detail: {
-      code: 'eval-result-not-serializable',
-      shape: classifyEvalResultShape(response.result),
-    },
-  });
-  return JSON.stringify({
-    jsonrpc: '2.0',
-    id: response.id,
-    error: inspectorErrorToJsonRpc(error),
-  }) as string;
-}
-
 function isValidId(v: unknown): v is number | string | null {
   return typeof v === 'number' || typeof v === 'string' || v === null;
 }
@@ -161,20 +121,17 @@ async function handleEnvelope(
     introspection: readonly ComponentIntrospectionDescriptor[];
     profiler: unknown | undefined;
     execution: unknown | undefined;
-    importModule: ((specifier: string) => Promise<unknown>) | undefined;
+    simulation: unknown | undefined;
     host: string;
     port: number;
   },
 ): Promise<JsonRpcResponse | null> {
-  let parsed: JsonRpcRequest | null;
+  let parsed: JsonRpcRequest;
   try {
     parsed = JSON.parse(raw) as JsonRpcRequest;
   } catch {
     return respondError(null, -32700, 'Parse error');
   }
-  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-    return respondError(null, -32600, 'Invalid Request');
-  }
   if (typeof parsed.method !== 'string') {
     const id = isValidId(parsed.id) ? parsed.id : null;
     return respondError(id, -32600, 'Invalid Request');
@@ -193,6 +150,7 @@ async function handleEnvelope(
         ...(ctx.rhiCapture !== undefined ? { rhiCapture: ctx.rhiCapture } : {}),
         ...(ctx.profiler !== undefined ? { profiler: ctx.profiler } : {}),
         ...(ctx.execution !== undefined ? { execution: ctx.execution } : {}),
+        ...(ctx.simulation !== undefined ? { simulation: ctx.simulation } : {}),
         ...(ctx.introspection.length > 0 ? { introspection: ctx.introspection } : {}),
       }),
     );
@@ -209,7 +167,7 @@ async function handleEnvelope(
         rhiCapture: ctx.rhiCapture,
         profiler: ctx.profiler,
         execution: ctx.execution,
-        ...(ctx.importModule === undefined ? {} : { importModule: ctx.importModule }),
+        simulation: ctx.simulation,
       });
       if (result.ok) {
         response = respondOk(id, result.value);
@@ -250,7 +208,7 @@ export function startServer(opts: StartServerOptions): Promise<Result<ConsoleHan
     const introspection = opts.introspection ?? [];
     const profiler = isProfilerRoot(opts.profiler) ? opts.profiler : undefined;
     const execution = isExecutionRoot(opts.execution) ? opts.execution : undefined;
-    const importModule = opts.importModule;
+    const simulation = opts.simulation;
     let settled = false;
     let boundPort = opts.port;
 
@@ -286,13 +244,13 @@ export function startServer(opts: StartServerOptions): Promise<Result<ConsoleHan
           introspection,
           profiler,
           execution,
-          importModule,
+          simulation,
           host,
           port: boundPort,
         })
           .then((response) => {
             if (response !== null && ws.readyState === ws.OPEN) {
-              ws.send(serializeResponse(response));
+              ws.send(JSON.stringify(response));
             }
           })
           .catch((e: unknown) => {
@@ -310,20 +268,16 @@ export function startServer(opts: StartServerOptions): Promise<Result<ConsoleHan
       settled = true;
       const address = wss.address();
       const port = typeof address === 'object' && address !== null ? address.port : opts.port;
-      let closePromise: Promise<void> | undefined;
       boundPort = port;
       const handle: ConsoleHandle = {
         port,
-        close: () => {
-          if (closePromise !== undefined) return closePromise;
-          closePromise = new Promise<void>((closeResolve) => {
+        close: () =>
+          new Promise<void>((closeResolve) => {
             for (const client of wss.clients) {
               client.terminate();
             }
             wss.close(() => closeResolve());
-          });
-          return closePromise;
-        },
+          }),
       };
       resolve(ok(handle));
     });

package/dist/__tests__/asset-runtime-inspection.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=asset-runtime-inspection.unit.test.d.ts.map

package/dist/__tests__/asset-runtime-inspection.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asset-runtime-inspection.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/asset-runtime-inspection.unit.test.ts"],"names":[],"mappings":""}

package/src/__tests__/asset-runtime-inspection.unit.test.ts

@@ -1,16 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildIntrospectDoc } from '../introspect';
-
-describe('remote asset runtime inspection', () => {
-  it('projects the bounded registry snapshot operations without owning registry state', () => {
-    const doc = buildIntrospectDoc('127.0.0.1', 5732, {
-      world: {},
-      renderer: {},
-      assets: { snapshot: () => ({ ready: [], pending: 0 }) },
-    }) as { roots: Record<string, { operations?: Record<string, string> }> };
-
-    expect(doc.roots.assets).toMatchObject({
-      operations: { load: 'assets.load(guid, expectedKind)', snapshot: 'assets.snapshot()' },
-    });
-  });
-});