@ignex/nova 0.1.1

package/src/generated/direct-ser.ts

@@ -0,0 +1,495 @@
+// @generated by scripts/direct-gen.ts — DO NOT EDIT
+import { encodeUtf8Into, ensureCapacity, utf8Len } from "../native/codec";
+import { checkInt64 } from "../core/int64-guard";
+import { anyEventNameToId, WIRE_VERSION, WIRE_HEADER_LEN } from "./registry";
+import type { AnyEventName, ControlEvents, Events } from "../schema";
+
+export type DirectCall = (...args: unknown[]) => number;
+
+/** dlopen specs for the direct fast-path symbols (canonical form — the
+ * output tail `(ptr, usize)` is upgraded to `(buffer, buffer_length)` by
+ * the `abi()` transformer in `src/native/ffi.ts` when supported). */
+export const directSymbols = {
+  fb_quote_serialize: {
+    args: ["cstring", "f64", "f64", "i64", "i64", "i64", "ptr", "usize"],
+    returns: "u64_fast",
+  },
+  fb_trade_serialize: {
+    args: ["cstring", "f64", "i64", "u32", "i64", "ptr", "usize"],
+    returns: "u64_fast",
+  },
+  fb_portfolio_serialize: {
+    args: ["cstring", "buffer", "usize", "f64", "f64", "i64", "cstring", "ptr", "usize"],
+    returns: "u64_fast",
+  },
+  fb_complex_serialize: {
+    args: ["cstring", "buffer", "usize", "buffer", "usize", "buffer", "usize", "buffer", "usize", "buffer", "usize", "u8", "f64", "i64", "ptr", "usize"],
+    returns: "u64_fast",
+  },
+  fb_big_val_serialize: {
+    args: ["cstring", "i64", "i64", "ptr", "usize"],
+    returns: "u64_fast",
+  },
+  fb_hello_serialize: {
+    args: ["i64", "buffer", "usize", "i64", "ptr", "usize"],
+    returns: "u64_fast",
+  },
+  fb_welcome_serialize: {
+    args: ["cstring", "buffer", "usize", "ptr", "usize"],
+    returns: "u64_fast",
+  },
+  fb_subscribe_serialize: {
+    args: ["cstring", "ptr", "usize"],
+    returns: "u64_fast",
+  },
+  fb_unsubscribe_serialize: {
+    args: ["cstring", "ptr", "usize"],
+    returns: "u64_fast",
+  },
+  fb_join_group_serialize: {
+    args: ["cstring", "ptr", "usize"],
+    returns: "u64_fast",
+  },
+  fb_leave_group_serialize: {
+    args: ["cstring", "ptr", "usize"],
+    returns: "u64_fast",
+  },
+  fb_snapshot_request_serialize: {
+    args: ["cstring", "ptr", "usize"],
+    returns: "u64_fast",
+  },
+  fb_ping_serialize: {
+    args: ["i64", "ptr", "usize"],
+    returns: "u64_fast",
+  },
+  fb_pong_serialize: {
+    args: ["i64", "ptr", "usize"],
+    returns: "u64_fast",
+  },
+} as const;
+
+/** sample objects for the bind-time self-test (representative values). */
+const directSamples: Record<string, unknown> = {
+  "quote": { "symbol": "SELFTEST", "bid": 1.5, "ask": 1.5, "bidSize": 123456, "askSize": 123456, "ts": 123456 },
+  "trade": { "symbol": "SELFTEST", "price": 1.5, "volume": 123456, "side": "buy", "ts": 123456 },
+  "portfolio": { "accountId": "SELFTEST", "positions": [{ "symbol": "SELFTEST", "quantity": 123456, "avgPrice": 1.5, "pnl": 1.5 }], "totalValue": 1.5, "cash": 1.5, "ts": 123456, "updatedBy": "SELFTEST" },
+  "complex": { "id": "SELFTEST", "names": ["a", "b"], "prices": [1.5, 2.5], "counts": [10, 20], "flags": [true, false], "tags": ["hot"], "active": true, "total": 1.5, "ts": 123456 },
+  "bigVal": { "id": "SELFTEST", "seq": 123456, "when": 123456 },
+  "hello": { "version": 123456, "caps": ["a", "b"], "lastSeq": 123456 },
+  "welcome": { "clientId": "SELFTEST", "groups": ["a", "b"] },
+  "subscribe": { "topic": "SELFTEST" },
+  "unsubscribe": { "topic": "SELFTEST" },
+  "joinGroup": { "group": "SELFTEST" },
+  "leaveGroup": { "group": "SELFTEST" },
+  "snapshotRequest": { "topic": "SELFTEST" },
+  "ping": { "ts": 123456 },
+  "pong": { "ts": 123456 },
+} as const;
+
+/** grow the packer scratch, write the u32 count, return the DataView. */
+function packHeader(holder: { v: Uint8Array }, dv: { v: DataView }, total: number, count: number): DataView {
+  if (holder.v.byteLength < total) { holder.v = ensureCapacity(holder.v, total); dv.v = new DataView(holder.v.buffer); }
+  const b = dv.v;
+  b.setUint32(0, count, true);
+  return b;
+}
+
+const SIDE = { buy: 0, sell: 1 } as const;
+const TAGS = { hot: 0, new: 1, sale: 2 } as const;
+
+/** zero-alloc encoder: fields straight into the (reusable) out buffer. */
+export function encodeQuote(call: DirectCall, o: unknown, out: Uint8Array): number {
+  const p = o as Events["quote"];
+  checkInt64("quote.bidSize", p.bidSize);
+  checkInt64("quote.askSize", p.askSize);
+  checkInt64("quote.ts", p.ts);
+  return call(p.symbol, p.bid, p.ask, p.bidSize, p.askSize, p.ts, out, out) as number;
+}
+
+/** zero-alloc encoder: fields straight into the (reusable) out buffer. */
+export function encodeTrade(call: DirectCall, o: unknown, out: Uint8Array): number {
+  const p = o as Events["trade"];
+  checkInt64("trade.volume", p.volume);
+  checkInt64("trade.ts", p.ts);
+  return call(p.symbol, p.price, p.volume, SIDE[p.side], p.ts, out, out) as number;
+}
+
+const portfolio_positionsHolder = { v: new Uint8Array(1024) };
+const portfolio_positionsDv = { v: new DataView(portfolio_positionsHolder.v.buffer) };
+function packPortfolioPositions(items: Events["portfolio"]["positions"], holder: { v: Uint8Array }, dv: { v: DataView }): number {
+  let total = 4;
+  for (const p of items) total += 4 + utf8Len(p.symbol) + 8 + 8 + 8;
+  const b = packHeader(holder, dv, total, items.length);
+  let off = 4;
+  for (const p of items) {
+    const symbolL = encodeUtf8Into(p.symbol, holder.v, off + 4); b.setUint32(off, symbolL, true); off += 4; off += symbolL;
+    b.setInt32(off, p.quantity | 0, true); b.setInt32(off + 4, Math.floor(p.quantity / 0x100000000), true); off += 8;
+    b.setFloat64(off, p.avgPrice, true); off += 8;
+    b.setFloat64(off, p.pnl, true); off += 8;
+  }
+  return total;
+}
+
+/** zero-alloc encoder: fields straight into the (reusable) out buffer. */
+export function encodePortfolio(call: DirectCall, o: unknown, out: Uint8Array): number {
+  const p = o as Events["portfolio"];
+  const positionsLen = packPortfolioPositions(p.positions, portfolio_positionsHolder, portfolio_positionsDv);
+  checkInt64("portfolio.ts", p.ts);
+  return call(p.accountId, portfolio_positionsHolder.v, positionsLen, p.totalValue, p.cash, p.ts, p.updatedBy ?? null, out, out) as number;
+}
+
+const complex_namesHolder = { v: new Uint8Array(1024) };
+const complex_namesDv = { v: new DataView(complex_namesHolder.v.buffer) };
+const complex_pricesHolder = { v: new Uint8Array(1024) };
+const complex_pricesDv = { v: new DataView(complex_pricesHolder.v.buffer) };
+const complex_countsHolder = { v: new Uint8Array(1024) };
+const complex_countsDv = { v: new DataView(complex_countsHolder.v.buffer) };
+const complex_flagsHolder = { v: new Uint8Array(1024) };
+const complex_flagsDv = { v: new DataView(complex_flagsHolder.v.buffer) };
+const complex_tagsHolder = { v: new Uint8Array(1024) };
+const complex_tagsDv = { v: new DataView(complex_tagsHolder.v.buffer) };
+function packComplexNames(items: Events["complex"]["names"], holder: { v: Uint8Array }, dv: { v: DataView }): number {
+  let total = 4;
+  for (const x of items) total += 4 + utf8Len(x);
+  const b = packHeader(holder, dv, total, items.length);
+  let off = 4;
+  for (const x of items) {
+    const l = encodeUtf8Into(x, holder.v, off + 4); b.setUint32(off, l, true); off += 4; off += l;
+  }
+  return total;
+}
+
+function packComplexPrices(items: Events["complex"]["prices"], holder: { v: Uint8Array }, dv: { v: DataView }): number {
+  let total = 4;
+  for (const x of items) total += 8;
+  const b = packHeader(holder, dv, total, items.length);
+  let off = 4;
+  for (const x of items) {
+    b.setFloat64(off, x, true); off += 8;
+  }
+  return total;
+}
+
+function packComplexCounts(items: Events["complex"]["counts"], holder: { v: Uint8Array }, dv: { v: DataView }): number {
+  let total = 4;
+  for (const x of items) total += 8;
+  const b = packHeader(holder, dv, total, items.length);
+  let off = 4;
+  for (const x of items) {
+    b.setInt32(off, x | 0, true); b.setInt32(off + 4, Math.floor(x / 0x100000000), true); off += 8;
+  }
+  return total;
+}
+
+function packComplexFlags(items: Events["complex"]["flags"], holder: { v: Uint8Array }, dv: { v: DataView }): number {
+  let total = 4;
+  for (const x of items) total += 1;
+  const b = packHeader(holder, dv, total, items.length);
+  let off = 4;
+  for (const x of items) {
+    b.setUint8(off, x ? 1 : 0); off += 1;
+  }
+  return total;
+}
+
+function packComplexTags(items: Events["complex"]["tags"], holder: { v: Uint8Array }, dv: { v: DataView }): number {
+  let total = 4;
+  for (const x of items) total += 4;
+  const b = packHeader(holder, dv, total, items.length);
+  let off = 4;
+  for (const x of items) {
+    b.setUint32(off, TAGS[x], true); off += 4;
+  }
+  return total;
+}
+
+/** zero-alloc encoder: fields straight into the (reusable) out buffer. */
+export function encodeComplex(call: DirectCall, o: unknown, out: Uint8Array): number {
+  const p = o as Events["complex"];
+  const namesLen = packComplexNames(p.names, complex_namesHolder, complex_namesDv);
+  const pricesLen = packComplexPrices(p.prices, complex_pricesHolder, complex_pricesDv);
+  const countsLen = packComplexCounts(p.counts, complex_countsHolder, complex_countsDv);
+  const flagsLen = packComplexFlags(p.flags, complex_flagsHolder, complex_flagsDv);
+  const tagsLen = packComplexTags(p.tags, complex_tagsHolder, complex_tagsDv);
+  checkInt64("complex.ts", p.ts);
+  return call(p.id, complex_namesHolder.v, namesLen, complex_pricesHolder.v, pricesLen, complex_countsHolder.v, countsLen, complex_flagsHolder.v, flagsLen, complex_tagsHolder.v, tagsLen, p.active ? 1 : 0, p.total, p.ts, out, out) as number;
+}
+
+/** zero-alloc encoder: fields straight into the (reusable) out buffer. */
+export function encodeBigVal(call: DirectCall, o: unknown, out: Uint8Array): number {
+  const p = o as Events["bigVal"];
+  checkInt64("bigVal.when", p.when);
+  return call(p.id, p.seq, p.when, out, out) as number;
+}
+
+const hello_capsHolder = { v: new Uint8Array(1024) };
+const hello_capsDv = { v: new DataView(hello_capsHolder.v.buffer) };
+function packHelloCaps(items: ControlEvents["hello"]["caps"], holder: { v: Uint8Array }, dv: { v: DataView }): number {
+  let total = 4;
+  for (const x of items) total += 4 + utf8Len(x);
+  const b = packHeader(holder, dv, total, items.length);
+  let off = 4;
+  for (const x of items) {
+    const l = encodeUtf8Into(x, holder.v, off + 4); b.setUint32(off, l, true); off += 4; off += l;
+  }
+  return total;
+}
+
+/** zero-alloc encoder: fields straight into the (reusable) out buffer. */
+export function encodeHello(call: DirectCall, o: unknown, out: Uint8Array): number {
+  const p = o as ControlEvents["hello"];
+  checkInt64("hello.version", p.version);
+  const capsLen = packHelloCaps(p.caps, hello_capsHolder, hello_capsDv);
+  checkInt64("hello.lastSeq", p.lastSeq);
+  return call(p.version, hello_capsHolder.v, capsLen, p.lastSeq, out, out) as number;
+}
+
+const welcome_groupsHolder = { v: new Uint8Array(1024) };
+const welcome_groupsDv = { v: new DataView(welcome_groupsHolder.v.buffer) };
+function packWelcomeGroups(items: ControlEvents["welcome"]["groups"], holder: { v: Uint8Array }, dv: { v: DataView }): number {
+  let total = 4;
+  for (const x of items) total += 4 + utf8Len(x);
+  const b = packHeader(holder, dv, total, items.length);
+  let off = 4;
+  for (const x of items) {
+    const l = encodeUtf8Into(x, holder.v, off + 4); b.setUint32(off, l, true); off += 4; off += l;
+  }
+  return total;
+}
+
+/** zero-alloc encoder: fields straight into the (reusable) out buffer. */
+export function encodeWelcome(call: DirectCall, o: unknown, out: Uint8Array): number {
+  const p = o as ControlEvents["welcome"];
+  const groupsLen = packWelcomeGroups(p.groups, welcome_groupsHolder, welcome_groupsDv);
+  return call(p.clientId, welcome_groupsHolder.v, groupsLen, out, out) as number;
+}
+
+/** zero-alloc encoder: fields straight into the (reusable) out buffer. */
+export function encodeSubscribe(call: DirectCall, o: unknown, out: Uint8Array): number {
+  const p = o as ControlEvents["subscribe"];
+  return call(p.topic, out, out) as number;
+}
+
+/** zero-alloc encoder: fields straight into the (reusable) out buffer. */
+export function encodeUnsubscribe(call: DirectCall, o: unknown, out: Uint8Array): number {
+  const p = o as ControlEvents["unsubscribe"];
+  return call(p.topic, out, out) as number;
+}
+
+/** zero-alloc encoder: fields straight into the (reusable) out buffer. */
+export function encodeJoinGroup(call: DirectCall, o: unknown, out: Uint8Array): number {
+  const p = o as ControlEvents["joinGroup"];
+  return call(p.group, out, out) as number;
+}
+
+/** zero-alloc encoder: fields straight into the (reusable) out buffer. */
+export function encodeLeaveGroup(call: DirectCall, o: unknown, out: Uint8Array): number {
+  const p = o as ControlEvents["leaveGroup"];
+  return call(p.group, out, out) as number;
+}
+
+/** zero-alloc encoder: fields straight into the (reusable) out buffer. */
+export function encodeSnapshotRequest(call: DirectCall, o: unknown, out: Uint8Array): number {
+  const p = o as ControlEvents["snapshotRequest"];
+  return call(p.topic, out, out) as number;
+}
+
+/** zero-alloc encoder: fields straight into the (reusable) out buffer. */
+export function encodePing(call: DirectCall, o: unknown, out: Uint8Array): number {
+  const p = o as ControlEvents["ping"];
+  checkInt64("ping.ts", p.ts);
+  return call(p.ts, out, out) as number;
+}
+
+/** zero-alloc encoder: fields straight into the (reusable) out buffer. */
+export function encodePong(call: DirectCall, o: unknown, out: Uint8Array): number {
+  const p = o as ControlEvents["pong"];
+  checkInt64("pong.ts", p.ts);
+  return call(p.ts, out, out) as number;
+}
+
+function hasNulQuote(o: unknown): boolean {
+  const p = o as Events["quote"];
+  return (
+    (typeof p.symbol === "string" && p.symbol.includes("\0"))
+  );
+}
+
+function hasNulTrade(o: unknown): boolean {
+  const p = o as Events["trade"];
+  return (
+    (typeof p.symbol === "string" && p.symbol.includes("\0"))
+  );
+}
+
+function hasNulPortfolio(o: unknown): boolean {
+  const p = o as Events["portfolio"];
+  return (
+    (typeof p.accountId === "string" && p.accountId.includes("\0")) ||
+    (p.positions ?? []).some((e) => typeof e.symbol === "string" && e.symbol.includes("\0")) ||
+    (typeof p.updatedBy === "string" && p.updatedBy.includes("\0"))
+  );
+}
+
+function hasNulComplex(o: unknown): boolean {
+  const p = o as Events["complex"];
+  return (
+    (typeof p.id === "string" && p.id.includes("\0")) ||
+    (p.names ?? []).some((s) => typeof s === "string" && s.includes("\0"))
+  );
+}
+
+function hasNulBigVal(o: unknown): boolean {
+  const p = o as Events["bigVal"];
+  return (
+    (typeof p.id === "string" && p.id.includes("\0"))
+  );
+}
+
+function hasNulHello(o: unknown): boolean {
+  const p = o as ControlEvents["hello"];
+  return (
+    (p.caps ?? []).some((s) => typeof s === "string" && s.includes("\0"))
+  );
+}
+
+function hasNulWelcome(o: unknown): boolean {
+  const p = o as ControlEvents["welcome"];
+  return (
+    (typeof p.clientId === "string" && p.clientId.includes("\0")) ||
+    (p.groups ?? []).some((s) => typeof s === "string" && s.includes("\0"))
+  );
+}
+
+function hasNulSubscribe(o: unknown): boolean {
+  const p = o as ControlEvents["subscribe"];
+  return (
+    (typeof p.topic === "string" && p.topic.includes("\0"))
+  );
+}
+
+function hasNulUnsubscribe(o: unknown): boolean {
+  const p = o as ControlEvents["unsubscribe"];
+  return (
+    (typeof p.topic === "string" && p.topic.includes("\0"))
+  );
+}
+
+function hasNulJoinGroup(o: unknown): boolean {
+  const p = o as ControlEvents["joinGroup"];
+  return (
+    (typeof p.group === "string" && p.group.includes("\0"))
+  );
+}
+
+function hasNulLeaveGroup(o: unknown): boolean {
+  const p = o as ControlEvents["leaveGroup"];
+  return (
+    (typeof p.group === "string" && p.group.includes("\0"))
+  );
+}
+
+function hasNulSnapshotRequest(o: unknown): boolean {
+  const p = o as ControlEvents["snapshotRequest"];
+  return (
+    (typeof p.topic === "string" && p.topic.includes("\0"))
+  );
+}
+
+function hasNulPing(o: unknown): boolean {
+  const p = o as ControlEvents["ping"];
+  return false;
+}
+
+function hasNulPong(o: unknown): boolean {
+  const p = o as ControlEvents["pong"];
+  return false;
+}
+
+/** per-event NUL pre-scan — true routes the payload to the JSON path (cstring truncates `\0`). */
+export const hasNulEncoders: Partial<Record<AnyEventName, (o: unknown) => boolean>> = {
+  quote: hasNulQuote,
+  trade: hasNulTrade,
+  portfolio: hasNulPortfolio,
+  complex: hasNulComplex,
+  bigVal: hasNulBigVal,
+  hello: hasNulHello,
+  welcome: hasNulWelcome,
+  subscribe: hasNulSubscribe,
+  unsubscribe: hasNulUnsubscribe,
+  joinGroup: hasNulJoinGroup,
+  leaveGroup: hasNulLeaveGroup,
+  snapshotRequest: hasNulSnapshotRequest,
+  ping: hasNulPing,
+  pong: hasNulPong,
+};
+
+export const directSymbolNames: Partial<Record<AnyEventName, string>> = {
+  quote: "fb_quote_serialize",
+  trade: "fb_trade_serialize",
+  portfolio: "fb_portfolio_serialize",
+  complex: "fb_complex_serialize",
+  bigVal: "fb_big_val_serialize",
+  hello: "fb_hello_serialize",
+  welcome: "fb_welcome_serialize",
+  subscribe: "fb_subscribe_serialize",
+  unsubscribe: "fb_unsubscribe_serialize",
+  joinGroup: "fb_join_group_serialize",
+  leaveGroup: "fb_leave_group_serialize",
+  snapshotRequest: "fb_snapshot_request_serialize",
+  ping: "fb_ping_serialize",
+  pong: "fb_pong_serialize",
+};
+
+export type DirectEncoder = (call: DirectCall, o: unknown, out: Uint8Array) => number;
+
+export const directEncoders: Partial<Record<AnyEventName, DirectEncoder>> = {
+  quote: encodeQuote,
+  trade: encodeTrade,
+  portfolio: encodePortfolio,
+  complex: encodeComplex,
+  bigVal: encodeBigVal,
+  hello: encodeHello,
+  welcome: encodeWelcome,
+  subscribe: encodeSubscribe,
+  unsubscribe: encodeUnsubscribe,
+  joinGroup: encodeJoinGroup,
+  leaveGroup: encodeLeaveGroup,
+  snapshotRequest: encodeSnapshotRequest,
+  ping: encodePing,
+  pong: encodePong,
+};
+
+/**
+ * Bind-time self-test for the direct fast-path symbols. Encodes each
+ * sample into `scratch` and verifies the frame invariant
+ * `out[0]` = WIRE_VERSION, `out[1..5]` = event id AND
+ * `bytes_written === WIRE_HEADER_LEN + 4 + size_prefix`
+ * (envelope header + 4-byte size prefix + flatbuffer). A signature drift,
+ * ABI mismatch, or encoder bug surfaces here instead of under load.
+ * Returns the list of symbol names to DISABLE (route via JSON path).
+ *
+ * `raw` must be the adapted symbol map (mode-aware) from ffi.ts.
+ */
+export function directSelfTest(raw: Record<string, (...args: unknown[]) => number>, scratch: Uint8Array): string[] {
+  const disabled: string[] = [];
+  const dv = new DataView(scratch.buffer, scratch.byteOffset, scratch.byteLength);
+  for (const [name, sample] of Object.entries(directSamples)) {
+    const symName = directSymbolNames[name as AnyEventName];
+    const enc = directEncoders[name as AnyEventName];
+    if (!symName || !enc) continue;
+    const call = raw[symName];
+    if (!call) { disabled.push(symName); continue; }
+    try {
+      const w = enc(call, sample, scratch) as number;
+      if (w === 0) { disabled.push(symName); continue; }
+      if (w > scratch.byteLength) continue; // needed-size path — not a failure
+      const size = dv.getUint32(scratch.byteOffset + WIRE_HEADER_LEN, true);
+      const gotId = dv.getUint32(scratch.byteOffset + 1, true);
+      if (scratch[0] !== WIRE_VERSION || gotId !== anyEventNameToId[name] || w !== WIRE_HEADER_LEN + 4 + size) disabled.push(symName);
+    } catch {
+      disabled.push(symName);
+    }
+  }
+  return disabled;
+}

package/src/generated/fbs/backend.fbs

@@ -0,0 +1,139 @@
+// @generated by scripts/typebox-to-fbs.ts — DO NOT EDIT
+// FlatBuffers schema derived from the TypeBox events registry (schema/index.ts).
+
+file_identifier "IGNX";
+
+enum Side : int32 {
+  BUY = 0,
+  SELL = 1,
+}
+
+enum Tags : int32 {
+  HOT = 0,
+  NEW = 1,
+  SALE = 2,
+}
+
+table Quote {
+  symbol:string;
+  bid:double;
+  ask:double;
+  bid_size:int64;
+  ask_size:int64;
+  ts:int64;
+}
+
+table Trade {
+  symbol:string;
+  price:double;
+  volume:int64;
+  side:Side;
+  ts:int64;
+}
+
+table PortfolioSnapshot {
+  account_id:string;
+  positions:[PortfolioPosition];
+  total_value:double;
+  cash:double;
+  ts:int64;
+  updated_by:string;
+}
+
+table PortfolioPosition {
+  symbol:string;
+  quantity:int64;
+  avg_price:double;
+  pnl:double;
+}
+
+table Complex {
+  id:string;
+  names:[string];
+  prices:[double];
+  counts:[int64];
+  flags:[bool];
+  tags:[Tags];
+  active:bool;
+  total:double;
+  ts:int64;
+}
+
+table Order {
+  order_id:string;
+  customer:Customer;
+  lines:[OrderLine];
+  notes:[string];
+  discounts:[double];
+  active:bool;
+  created_at:int64;
+  billing:OrderBilling;
+}
+
+table Customer {
+  id:string;
+  name:string;
+  vip:bool;
+  loyalty_points:int64;
+  rating:double;
+}
+
+table OrderLine {
+  sku:string;
+  qty:int64;
+  unit_price:double;
+  tags:[Tags];
+}
+
+table OrderBilling {
+  id:string;
+  name:string;
+  vip:bool;
+  loyalty_points:int64;
+  rating:double;
+}
+
+table BigVal {
+  id:string;
+  seq:int64;
+  when:int64;
+}
+
+table Hello {
+  version:int64;
+  caps:[string];
+  last_seq:int64;
+}
+
+table Welcome {
+  client_id:string;
+  groups:[string];
+}
+
+table Subscribe {
+  topic:string;
+}
+
+table Unsubscribe {
+  topic:string;
+}
+
+table JoinGroup {
+  group:string;
+}
+
+table LeaveGroup {
+  group:string;
+}
+
+table SnapshotRequest {
+  topic:string;
+}
+
+table Ping {
+  ts:int64;
+}
+
+table Pong {
+  ts:int64;
+}