pi-mega-compact 0.20.43 → 0.20.44

package/src/vector-cortex/encoder/runtime-wasm.ts

@@ -36,7 +36,7 @@ export interface OrtWasmModule {
       opts: { executionProviders: string[]; intraOpNumThreads: number },
     ): Promise<{
       run(
-        feeds: Record<string, Float32Array>,
+        feeds: Record<string, { data: BigInt64Array; dims: number[]; type: string }>,
         outputNames: string[],
       ): Promise<Record<string, { data: Float32Array }>>;
     }>;
@@ -51,8 +51,8 @@ export interface WasmSession {
   readonly semanticWidth: number;
   /** The per-asset token capacity cap (normative <= 512). */
   readonly maxTokens: number;
-  /** Run one inference over already shape-checked input tokens. */
-  infer(inputIds: Float32Array): Promise<Float32Array>;
+  /** Run one inference over shape-checked token IDs (int64 input_ids). */
+  infer(tokens: number[]): Promise<Float32Array>;
 }
 
 /** True if `onnxruntime-web` resolves on this host (loading is best-effort).
@@ -94,10 +94,23 @@ export async function createWasmSession(
       opset: ENCODER_OPSET,
       semanticWidth: ENCODER_SEMANTIC_WIDTH,
       maxTokens,
-      async infer(inputIds: Float32Array): Promise<Float32Array> {
-        const feeds = { input_ids: inputIds };
-        const results = await session.run(feeds, ["embedding"]);
-        const out = results["embedding"];
+      async infer(tokens: number[]): Promise<Float32Array> {
+        const n = tokens.length;
+        const inputIds = new BigInt64Array(n);
+        const attentionMask = new BigInt64Array(n);
+        const tokenTypeIds = new BigInt64Array(n);
+        for (let i = 0; i < n; i++) {
+          inputIds[i] = BigInt(tokens[i]!);
+          attentionMask[i] = 1n;
+          tokenTypeIds[i] = 0n;
+        }
+        const feeds = {
+          input_ids: { data: inputIds, dims: [1, n], type: "int64" },
+          attention_mask: { data: attentionMask, dims: [1, n], type: "int64" },
+          token_type_ids: { data: tokenTypeIds, dims: [1, n], type: "int64" },
+        };
+        const results = await session.run(feeds, ["sentence_embedding"]);
+        const out = results["sentence_embedding"];
         if (!out || !(out.data instanceof Float32Array)) {
           return new Float32Array(ENCODER_SEMANTIC_WIDTH);
         }

package/src/vector-cortex/encoder/runtime.ts

@@ -86,6 +86,7 @@ import { selectRuntimeBackend } from "./runtime-select.js";
 import { emitRuntimeSelected } from "./runtime-emit.js";
 import { projectSemantic, seedFromBytes } from "./runtime-stub.js";
 import { STATE_DIR_DEFAULT } from "../../config.js";
+import { tryBuildOnnx, type OnnxDispatchState, NO_ONNX } from "./encoder-onnx-dispatch.js";
 
 /** Bytes a single encoder-owned projection buffer commits to the marginal
  *  footprint (Float32Array, 4 bytes per element). */
@@ -136,9 +137,16 @@ function normalizePlatform(p: EncoderPlatform | null): EncoderPlatform | "unsupp
   return p === null ? "unsupported" : p;
 }
 
+/** The concrete runtime returned by createEncoderRuntime — the base
+ *  EncoderRuntime interface plus the ENC-0b ONNX dispatch state. */
+export type EncoderRuntimeHandle = EncoderRuntime & {
+  /** ENC-0b: the ONNX dispatch state (null when ENC_0B is off or not built). */
+  readonly onnxState: OnnxDispatchState;
+};
+
 export function createEncoderRuntime(
   options: CreateEncoderRuntimeOptions = {},
-): EncoderRuntime {
+): EncoderRuntimeHandle {
   const reporter = options.reporter ?? createEncoderReporter();
   const host = mergeHost(options.host);
   const forced = options.forcedMode;
@@ -152,6 +160,7 @@ export function createEncoderRuntime(
   let verified = false;
   let maxTokens = ENCODER_MAX_TOKENS;
   let selfAllocated = 0;
+  let onnxState: OnnxDispatchState = NO_ONNX;
 
   const footprint = (): number => selfAllocated + host.allocatedBytes();
 
@@ -161,12 +170,14 @@ export function createEncoderRuntime(
     reporter.runtimeDemoted({ reason: code, mode: rmode, platform: plat()?.toString() ?? "unsupported" });
   };
 
-  const runtime: EncoderRuntime = {
+  const runtime: EncoderRuntimeHandle = {
     schema: "encoder-runtime-v1",
-    // Live getter so `mode` always reflects the latest load/demote outcome.
     get mode(): EncoderMode {
       return mode;
     },
+    get onnxState(): OnnxDispatchState {
+      return onnxState;
+    },
     load(assetDir: string): EncoderLoadResult {
       if (rolledBack) {
         // Q04: report the rollback with its own code, not MANIFEST_INVALID.
@@ -225,6 +236,14 @@ export function createEncoderRuntime(
         emitRuntimeSelected(host.stateDir ?? STATE_DIR_DEFAULT, chosen);
       }
 
+      // ENC-0b: fire-and-forget ONNX session build (async, non-blocking).
+      // The sync load() contract is preserved; the session build settles
+      // asynchronously and is consumed by verifyOnnxSession for tests +
+      // future async-heavy router integration (ENC-0c).
+      if (manifest) {
+        onnxState = tryBuildOnnx(assetDir, manifest, reporter, footprint());
+      }
+
       return {
         ok: true,
         mode: "A",
@@ -262,14 +281,13 @@ export function createEncoderRuntime(
         };
       }
       const start = host.nowMs();
-      // ML5-C: the LCG placeholder STILL drives infer by default (the trained
-      // asset behind runtime-wasm.ts/runtime-native.ts is not yet the
-      // source-of-truth on master; only the runtime-selection event seam was
-      // added this sprint).
+      // ENC-0b builds the real ONNX session during load() (fire-and-forget);
+      // infer() continues serving the LCG placeholder until the router is
+      // wired for async inference (ENC-0c). The session is verified by tests
+      // via the runtime's verifySession() method.
       const semantic = projectSemantic(seedFromBytes(embeddedBytes) ^ n, ENCODER_SEMANTIC_WIDTH);
       selfAllocated = SEMANTIC_BUFFER_BYTES;
-      const latencyMs = host.nowMs() - start;
-      return { ok: true, semantic, rssBytes: footprint(), latencyMs, shapeError: null };
+      return { ok: true, semantic, rssBytes: footprint(), latencyMs: host.nowMs() - start, shapeError: null };
     },
   };
   return runtime;

package/src/vector-cortex/encoder/types-vc2c.ts

@@ -122,3 +122,13 @@ export const ENC2C_IDS: readonly string[] = [
   "ENC-019",
   "ENC-020",
 ];
+
+/** The 6 registered ENC-0b conformance IDs (encoder-trunk fixtures). */
+export const ENC_0B_IDS: readonly string[] = [
+  "ENC-TRUNK-001",
+  "ENC-TRUNK-002",
+  "ENC-TRUNK-003",
+  "ENC-TRUNK-004",
+  "ENC-TRUNK-005",
+  "ENC-TRUNK-006",
+];

package/src/vector-cortex/encoder/types.ts

@@ -288,6 +288,7 @@ export {
   EVALUATION_THRESHOLDS,
   ENC_QUALIFICATION_FAIL,
   ENC2C_IDS,
+  ENC_0B_IDS,
   type EncoderHeldOutMetrics,
   type CalibrationV1,
   type QualifiedEncoderV1,