@irtio/protocol 0.6.0 → 0.7.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _irtio_schema from '@irtio/schema';
-import { ByteReader, RpcMap, ServerRpcs, AnySchema, RpcDesc, InstanceOf, Schema, SchemaDefs, SchemaRpc, SchemaRoles } from '@irtio/schema';
+import { ByteReader, RpcMap, ServerRpcs, AnySchema, RpcDesc, InstanceOf, Schema, SchemaDefs, SchemaRpc, SchemaRoles, SchemaMessages } from '@irtio/schema';
 
 /**
  * Frame envelope: one type byte, then an opaque payload. `encodeFrame`/`decodeFrame` only
@@ -9,12 +9,18 @@ import { ByteReader, RpcMap, ServerRpcs, AnySchema, RpcDesc, InstanceOf, Schema,
  * Wire protocol version (u8), bumped on any breaking change to framing or payload shapes.
  *
  * 2: `WELCOME`'s tick slot carries the room's tick rate in ticks per second, where version 1
- * carried the interval in whole milliseconds. The slot kept its width and type, so a version 1
- * client would read `60` as a 60 ms interval and quietly run a four-times-too-long interpolation
- * delay and a wrong physics timestep. The bump turns that into `E_PROTOCOL_VERSION` at join,
- * which is a client bundle that needs redeploying rather than an afternoon of debugging.
+ * carried the interval in whole milliseconds (`b28a325`). The slot kept its width and type, so a
+ * version 1 client would read `60` as a 60 ms interval and quietly run a four-times-too-long
+ * interpolation delay and a wrong physics timestep.
+ *
+ * 3: `CALL` carries the caller's `clientTick` between `rpcId` and the params (D72, lag
+ * compensation). The params are rest-of-buffer, so an older server reading a version 3 `CALL`
+ * would take four bytes of the stamp as the head of the params and decode nonsense. Either bump
+ * turns the mismatch into `E_PROTOCOL_VERSION` at join, which is a client bundle that needs
+ * redeploying rather than an afternoon of debugging. 2 and 3 landed on separate branches the
+ * same day and met at the M6 wave 1 merge; both are spent.
  */
-declare const PROTOCOL_VERSION = 2;
+declare const PROTOCOL_VERSION = 3;
 declare const FrameType: {
     readonly HELLO: 1;
     readonly WELCOME: 2;
@@ -250,6 +256,25 @@ declare const ErrorCode: {
         readonly code: 33;
         readonly message: "no capacity in region {region}; add a server or raise maxVms";
     };
+    /**
+     * M6 lane A (D68-d): an operator deleted this room, and its stored state is gone.
+     *
+     * Its own code rather than `E_KICKED` or `E_ROOM_CLOSED`, and the difference between the three is
+     * the reason it exists. `E_KICKED` is the room's own code deciding one player should leave, and
+     * a client's right answer is usually to show a message and stay in the game. `E_ROOM_CLOSED` is
+     * a room ending normally; rejoining makes a fresh one and nothing was lost. This is neither: the
+     * room's state has been deleted from outside the game, deliberately, by somebody with a rooms
+     * API credential. A client that reconnects gets an empty room rather than the one it was in.
+     * Different thing to tell a player, different thing for a client to do, different code.
+     *
+     * Fatal, which is load-bearing: `@irtio/client`'s fatal path leaves for good rather than
+     * reconnecting, and that is what stops a deleted room from being immediately recreated by the
+     * very clients that were in it. Close code {@link CLOSE_ROOM_DELETED}.
+     */
+    readonly E_ROOM_DELETED: {
+        readonly code: 34;
+        readonly message: "room {roomId} was deleted by an operator; its stored state is gone";
+    };
 };
 /**
  * The WebSocket close code the router uses for {@link ErrorCode.E_PLACEMENT}: RFC 6455's 1013,
@@ -266,6 +291,16 @@ declare const CLOSE_TRY_AGAIN_LATER = 1013;
  * they may not have. 4290 echoes HTTP 429 for the same reason a person would guess it does.
  */
 declare const CLOSE_EGRESS_WALL = 4290;
+/**
+ * The WebSocket close code for {@link ErrorCode.E_ROOM_DELETED} (D68-d).
+ *
+ * In the application range beside {@link CLOSE_EGRESS_WALL}, and its own value for the same
+ * reason: a developer watching sockets close has to be able to tell an operator deleting a room
+ * from a wall, from a policy refusal, and from a crash, without a log they may not have. 4291 sits
+ * next to 4290 because both are "the platform stopped this on purpose", and the two are one apart
+ * so a grep for `429` in a close-code histogram finds both.
+ */
+declare const CLOSE_ROOM_DELETED = 4291;
 type ErrorCodeName = keyof typeof ErrorCode;
 interface ErrorCatalogueEntry {
     readonly name: ErrorCodeName;
@@ -455,6 +490,17 @@ declare function encodeSchemaFrame(canonical: string): Uint8Array;
 interface Call {
     readonly reqId: number;
     readonly rpcId: number;
+    /**
+     * D72: the newest authoritative tick the caller had applied when it sent this `CALL`, so a room
+     * can answer the shot against the world the shooter was looking at (`ctx.clientTick`,
+     * `room.rewind`). `0` means "no stamp" — a server-to-client `CALL`, or a client that does not
+     * send one — and ticks start at 1, so zero can never be a real tick.
+     *
+     * It is a client-supplied number that selects which past the server answers from, and a client
+     * can lie about it. What a lie can reach is bounded by the room's history depth, and the room
+     * decides what it does with the answer; `concepts/lag-compensation.md` says both.
+     */
+    readonly clientTick?: number;
     /** Rest-of-buffer: opaque schema-codec-encoded params (not length-prefixed). */
     readonly params: Uint8Array;
 }
@@ -659,13 +705,60 @@ interface Msg {
     readonly target: MsgTarget;
     /** Rest-of-buffer: opaque application payload. */
     readonly payload: Uint8Array;
+    /**
+     * D70: present when this is a **typed** message — one of the shapes the schema declares, whose
+     * `payload` is `encodeFields(schema.messages[index].fields, value)` rather than opaque bytes.
+     *
+     * Absent for a raw `room.message(target, bytes)`. The two never mix: a receiver hands a typed
+     * frame only to typed listeners and a raw frame only to raw ones, on the client and in a room
+     * alike, so game code is never handed one under the other's API.
+     */
+    readonly typed?: {
+        readonly index: number;
+    };
 }
+/**
+ * D70 typed peer messages: an **envelope**, not a sixth address.
+ *
+ * The addressing byte is the one byte the format already spends on every MSG, so a typed message
+ * costs a discriminator it was going to pay for plus two bytes of index — no new `FrameType`, and
+ * directed delivery keeps working because the envelope carries a target of its own right after
+ * the index. Layout:
+ *
+ *     [5][index u16 LE][inner target kind][inner target fields][encoded payload]
+ *
+ * The inner target is the same vocabulary as an untyped MSG minus voice: `all`/`client`/`role`
+ * inbound, and the sender's `client` or `server` on the way out (the fan-out rewrites the slot,
+ * exactly as it does for raw bytes). `voice` is refused on both encode and decode — a typed
+ * envelope is authored by game code, and voice signaling must stay unrepresentable there.
+ *
+ * `isVoiceMsg` is unaffected: a typed frame's first byte is 5, never 4.
+ */
+declare const MSG_KIND_TYPED = 5;
 /**
  * A one-byte peek: is this MSG payload voice signaling? The supervisor calls this on every MSG
  * before deciding where the frame goes, so it must not allocate or decode. An empty payload is
  * not voice (it is malformed, and the existing paths report that).
  */
 declare function isVoiceMsg(payload: Uint8Array): boolean;
+/**
+ * D70: the same one-byte peek for a typed envelope. The supervisor uses it on the hot frame path
+ * for the same reason it uses `isVoiceMsg` — to decide where a frame goes without decoding it.
+ */
+declare function isTypedMsg(payload: Uint8Array): boolean;
+/**
+ * D70: may this typed envelope be **accepted from a client**?
+ *
+ * A three-byte peek, no allocation: an inbound typed message may address `all`, a client or a
+ * role, and nothing else. `server` has no meaning on the peer path (a room observes through
+ * `onMessage`; there is no typed server handler, by design) and `voice` must never be authorable
+ * by game code. Both are dropped by whoever sees the frame first, which is the supervisor above
+ * the relay fork and the relay host in the shared process.
+ *
+ * Returns `false` for anything too short to read, so a truncated frame is refused rather than
+ * assumed.
+ */
+declare function typedMsgFromClientOk(payload: Uint8Array): boolean;
 declare function encodeMsg(m: Msg): Uint8Array;
 declare function decodeMsg(bytes: Uint8Array): Msg;
 
@@ -794,7 +887,7 @@ type PresenceRecord = InstanceOf<typeof presenceEntity>;
  */
 declare function withBuiltins<S extends AnySchema>(schema: S): Schema<SchemaDefs<S> & {
     clients: typeof presenceEntity;
-}, SchemaRpc<S>, SchemaRoles<S>>;
+}, SchemaRpc<S>, SchemaRoles<S>, SchemaMessages<S>>;
 /**
  * The schema of a room with nothing deployed — no builder collections, just the
  * built-in presence merged by `withBuiltins`. The supervisor's relay forwarder encodes presence
@@ -803,7 +896,7 @@ declare function withBuiltins<S extends AnySchema>(schema: S): Schema<SchemaDefs
  */
 declare const relaySchema: Schema<{
     clients: typeof presenceEntity;
-}, {}, readonly string[]>;
+}, {}, readonly string[], {}>;
 /** The `schemaHash8` a relay HELLO carries: 8 zero bytes ("no schema"). */
 declare const RELAY_HASH8: Uint8Array;
 declare function isRelayHash8(hash8: Uint8Array): boolean;
@@ -1518,4 +1611,4 @@ declare function originAllowed(origins: readonly string[], allowNoOrigin: boolea
  */
 declare function parseOriginList(raw: string | undefined): readonly string[];
 
-export { type AttributeOptions, BUS_CHANNEL_RE, BUS_ERRORS, BUS_LIMITS, BUS_MAILBOX_PREFIX, BUS_OUTBOX, BUS_OUTBOX_PREFIX, BUS_SHARD_STARTING, type BusErrorCode, type BusMailboxEntry, type BusOutboxEntry, type BusProblem, CLOSE_EGRESS_WALL, CLOSE_TRY_AGAIN_LATER, CODE_ALPHABET, CPU_QUOTA_PCT_MAX, CPU_QUOTA_PCT_MIN, type Call, type ChurnIds, type ClientCallable, type Credential, DEFAULT_MAX_AWAKE, DEFAULT_MEMORY_MB, DEFAULT_ROOM_TYPE, EMPTY_PROFILE, ERROR_CATALOGUE, type ErrorCatalogueEntry, ErrorCode, type ErrorCodeDef, type ErrorCodeName, type ErrorPayload, type Frame, FrameType, HELLO_SCHEMA_SWAP_BIT, type Hello, MATCH_CODE_LENGTH, MAX_AWAKE_MAX, type Msg, type MsgTarget, NATIVE_RESERVE_FRACTION, PHYSICS_HEADROOM_MIB, PRESENCE_COLLECTION, PROFILE_KINDS, PROTOCOL_VERSION, type ParsedRoomId, type Ping, type Pong, type PresenceRecord, type ProfileKind, ProfileLedger, type ProfileRow, type ProfileSnapshot, RELAY_HASH8, RETENTION_MAX_MS, RETENTION_MIN_MS, RETENTION_RE, ROOMS_PER_VCPU, ROOM_CLASS_MAX_MB, ROOM_ID_RE, ROOM_MEMORY_MB_MAX, ROOM_MEMORY_MB_MIN, ROOM_TYPE_DELIMITER, ROOM_TYPE_RE, type Reply, type RoomSizeClass, type RoomTypeSizing, SUPERVISOR_BASELINE_MIB, VM_MEM_MIB_MAX, VM_MEM_MIB_MIN, type VmCpuSizing, type VmSizing, type VoiceClientMessage, type VoicePeer, type VoiceServerMessage, type VoiceTransportInfo, type Welcome, YOUNG_GEN_MB, builtinRpcs, busChannelProblem, busPayloadProblem, correctPayload, declarationsFit, decodeCall, decodeErrorPayload, decodeFrame, decodeHello, decodeMsg, decodePing, decodePong, decodeReply, decodeVoiceMessage, decodeWelcome, deltaPayload, diffProfiles, encodeCall, encodeCorrectFrame, encodeDeltaFrame, encodeErrorPayload, encodeFrame, encodeHello, encodeMsg, encodePing, encodePong, encodeReply, encodeSchemaFrame, encodeVoiceMessage, encodeWelcome, encodeWriteFrame, errorByCode, formatError, formatRoomId, isFrameType, isLocalhostOrigin, isMailboxAlarm, isOutboxAlarm, isRelayHash8, isVoiceMsg, mergeProfiles, nativeReserveOf, originAllowed, parseOriginList, parseRetention, parseRoomId, presenceEntity, readCorrectAppliedTick, readCorrectClientTick, readSchemaPayload, relaySchema, requestOwnership, roomClassFor, roomClassOfSource, roomHoursSourceFor, rpcByIdOf, rpcIdOf, rpcTable, scaleProfile, schemaPayload, topProfileRows, typeFootprintMib, vmCpuFor, vmSizeFor, withBuiltins, writePayload };
+export { type AttributeOptions, BUS_CHANNEL_RE, BUS_ERRORS, BUS_LIMITS, BUS_MAILBOX_PREFIX, BUS_OUTBOX, BUS_OUTBOX_PREFIX, BUS_SHARD_STARTING, type BusErrorCode, type BusMailboxEntry, type BusOutboxEntry, type BusProblem, CLOSE_EGRESS_WALL, CLOSE_ROOM_DELETED, CLOSE_TRY_AGAIN_LATER, CODE_ALPHABET, CPU_QUOTA_PCT_MAX, CPU_QUOTA_PCT_MIN, type Call, type ChurnIds, type ClientCallable, type Credential, DEFAULT_MAX_AWAKE, DEFAULT_MEMORY_MB, DEFAULT_ROOM_TYPE, EMPTY_PROFILE, ERROR_CATALOGUE, type ErrorCatalogueEntry, ErrorCode, type ErrorCodeDef, type ErrorCodeName, type ErrorPayload, type Frame, FrameType, HELLO_SCHEMA_SWAP_BIT, type Hello, MATCH_CODE_LENGTH, MAX_AWAKE_MAX, MSG_KIND_TYPED, type Msg, type MsgTarget, NATIVE_RESERVE_FRACTION, PHYSICS_HEADROOM_MIB, PRESENCE_COLLECTION, PROFILE_KINDS, PROTOCOL_VERSION, type ParsedRoomId, type Ping, type Pong, type PresenceRecord, type ProfileKind, ProfileLedger, type ProfileRow, type ProfileSnapshot, RELAY_HASH8, RETENTION_MAX_MS, RETENTION_MIN_MS, RETENTION_RE, ROOMS_PER_VCPU, ROOM_CLASS_MAX_MB, ROOM_ID_RE, ROOM_MEMORY_MB_MAX, ROOM_MEMORY_MB_MIN, ROOM_TYPE_DELIMITER, ROOM_TYPE_RE, type Reply, type RoomSizeClass, type RoomTypeSizing, SUPERVISOR_BASELINE_MIB, VM_MEM_MIB_MAX, VM_MEM_MIB_MIN, type VmCpuSizing, type VmSizing, type VoiceClientMessage, type VoicePeer, type VoiceServerMessage, type VoiceTransportInfo, type Welcome, YOUNG_GEN_MB, builtinRpcs, busChannelProblem, busPayloadProblem, correctPayload, declarationsFit, decodeCall, decodeErrorPayload, decodeFrame, decodeHello, decodeMsg, decodePing, decodePong, decodeReply, decodeVoiceMessage, decodeWelcome, deltaPayload, diffProfiles, encodeCall, encodeCorrectFrame, encodeDeltaFrame, encodeErrorPayload, encodeFrame, encodeHello, encodeMsg, encodePing, encodePong, encodeReply, encodeSchemaFrame, encodeVoiceMessage, encodeWelcome, encodeWriteFrame, errorByCode, formatError, formatRoomId, isFrameType, isLocalhostOrigin, isMailboxAlarm, isOutboxAlarm, isRelayHash8, isTypedMsg, isVoiceMsg, mergeProfiles, nativeReserveOf, originAllowed, parseOriginList, parseRetention, parseRoomId, presenceEntity, readCorrectAppliedTick, readCorrectClientTick, readSchemaPayload, relaySchema, requestOwnership, roomClassFor, roomClassOfSource, roomHoursSourceFor, rpcByIdOf, rpcIdOf, rpcTable, scaleProfile, schemaPayload, topProfileRows, typeFootprintMib, typedMsgFromClientOk, vmCpuFor, vmSizeFor, withBuiltins, writePayload };

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/frame.ts
-var PROTOCOL_VERSION = 2;
+var PROTOCOL_VERSION = 3;
 var FrameType = {
   HELLO: 1,
   WELCOME: 2,
@@ -148,10 +148,32 @@ var ErrorCode = {
   E_PLACEMENT: {
     code: 33,
     message: "no capacity in region {region}; add a server or raise maxVms"
+  },
+  // ---- M6 lane A: rooms API ----
+  /**
+   * M6 lane A (D68-d): an operator deleted this room, and its stored state is gone.
+   *
+   * Its own code rather than `E_KICKED` or `E_ROOM_CLOSED`, and the difference between the three is
+   * the reason it exists. `E_KICKED` is the room's own code deciding one player should leave, and
+   * a client's right answer is usually to show a message and stay in the game. `E_ROOM_CLOSED` is
+   * a room ending normally; rejoining makes a fresh one and nothing was lost. This is neither: the
+   * room's state has been deleted from outside the game, deliberately, by somebody with a rooms
+   * API credential. A client that reconnects gets an empty room rather than the one it was in.
+   * Different thing to tell a player, different thing for a client to do, different code.
+   *
+   * Fatal, which is load-bearing: `@irtio/client`'s fatal path leaves for good rather than
+   * reconnecting, and that is what stops a deleted room from being immediately recreated by the
+   * very clients that were in it. Close code {@link CLOSE_ROOM_DELETED}.
+   */
+  E_ROOM_DELETED: {
+    code: 34,
+    message: "room {roomId} was deleted by an operator; its stored state is gone"
   }
+  // ---- end M6 lane A ----
 };
 var CLOSE_TRY_AGAIN_LATER = 1013;
 var CLOSE_EGRESS_WALL = 4290;
+var CLOSE_ROOM_DELETED = 4291;
 var ERROR_CATALOGUE = Object.keys(ErrorCode).map((name) => ({ name, code: ErrorCode[name].code, message: ErrorCode[name].message }));
 var BY_CODE = new Map(
   ERROR_CATALOGUE.map((e) => [e.code, e])
@@ -347,6 +369,7 @@ function encodeCall(c) {
   const w = new ByteWriter2();
   w.u32(c.reqId);
   w.u16(c.rpcId);
+  w.u32(c.clientTick ?? 0);
   w.bytes(c.params);
   return w.finish();
 }
@@ -354,8 +377,9 @@ function decodeCall(bytes) {
   const r = new ByteReader2(bytes);
   const reqId = r.u32();
   const rpcId = r.u16();
+  const clientTick = r.u32();
   const params = r.rest();
-  return { reqId, rpcId, params };
+  return { reqId, rpcId, clientTick, params };
 }
 function encodeReply(r) {
   const w = new ByteWriter2();
@@ -434,6 +458,11 @@ function withBuiltins(schema) {
       {
         rpc: schema.rpc,
         roles: schema.roles,
+        // D70: message shapes travel with the extension. The builder's hash is what HELLO carries
+        // and what a typed message is validated against, but the runtime reaches its schema
+        // through `ext` in several places, and an extension that quietly dropped `messages` would
+        // make a declared message decodable on one side of the room and not the other.
+        ...schema.messageDefs !== void 0 && Object.keys(schema.messageDefs).length > 0 ? { messages: schema.messageDefs } : {},
         ...schema.project !== void 0 ? { project: schema.project } : {},
         allowReservedNames: true
       }
@@ -828,36 +857,87 @@ var MSG_KIND_CLIENT = 1;
 var MSG_KIND_ROLE = 2;
 var MSG_KIND_SERVER = 3;
 var MSG_KIND_VOICE = 4;
+var MSG_KIND_TYPED = 5;
 function isVoiceMsg(payload) {
   return payload.length > 0 && payload[0] === MSG_KIND_VOICE;
 }
-function encodeMsg(m) {
-  const w = new ByteWriter3();
-  switch (m.target.kind) {
+function isTypedMsg(payload) {
+  return payload.length > 0 && payload[0] === MSG_KIND_TYPED;
+}
+function typedMsgFromClientOk(payload) {
+  if (payload.length < 4 || payload[0] !== MSG_KIND_TYPED) return false;
+  const inner = payload[3];
+  return inner === MSG_KIND_ALL || inner === MSG_KIND_CLIENT || inner === MSG_KIND_ROLE;
+}
+function writeTarget(w, target) {
+  switch (target.kind) {
     case "all":
       w.u8(MSG_KIND_ALL);
-      break;
+      return;
     case "client":
       w.u8(MSG_KIND_CLIENT);
-      w.str(m.target.clientId);
-      break;
+      w.str(target.clientId);
+      return;
     case "role":
       w.u8(MSG_KIND_ROLE);
-      w.str(m.target.role);
-      break;
+      w.str(target.role);
+      return;
     case "server":
       w.u8(MSG_KIND_SERVER);
-      break;
+      return;
     case "voice":
       w.u8(MSG_KIND_VOICE);
-      break;
+      return;
   }
+}
+function readTarget(r) {
+  const kind = r.u8();
+  switch (kind) {
+    case MSG_KIND_ALL:
+      return { kind: "all" };
+    case MSG_KIND_CLIENT:
+      return { kind: "client", clientId: r.str() };
+    case MSG_KIND_ROLE:
+      return { kind: "role", role: r.str() };
+    case MSG_KIND_SERVER:
+      return { kind: "server" };
+    case MSG_KIND_VOICE:
+      return { kind: "voice" };
+    default:
+      throw new Error(`decodeMsg: unknown target discriminator ${kind}`);
+  }
+}
+function encodeMsg(m) {
+  const w = new ByteWriter3();
+  if (m.typed) {
+    if (m.target.kind === "voice") {
+      throw new Error("encodeMsg: a typed message cannot address voice");
+    }
+    const index = m.typed.index;
+    if (!Number.isInteger(index) || index < 0 || index > 65535) {
+      throw new Error(`encodeMsg: typed message index out of range: ${String(index)}`);
+    }
+    w.u8(MSG_KIND_TYPED);
+    w.u16(index);
+    writeTarget(w, m.target);
+    w.bytes(m.payload);
+    return w.finish();
+  }
+  writeTarget(w, m.target);
   w.bytes(m.payload);
   return w.finish();
 }
 function decodeMsg(bytes) {
   const r = new ByteReader4(bytes);
   const kind = r.u8();
+  if (kind === MSG_KIND_TYPED) {
+    const index = r.u16();
+    const target2 = readTarget(r);
+    if (target2.kind === "voice") {
+      throw new Error("decodeMsg: a typed message cannot address voice");
+    }
+    return { target: target2, payload: r.rest(), typed: { index } };
+  }
   let target;
   switch (kind) {
     case MSG_KIND_ALL:
@@ -1225,6 +1305,7 @@ export {
   BUS_OUTBOX_PREFIX,
   BUS_SHARD_STARTING,
   CLOSE_EGRESS_WALL,
+  CLOSE_ROOM_DELETED,
   CLOSE_TRY_AGAIN_LATER,
   CODE_ALPHABET,
   CPU_QUOTA_PCT_MAX,
@@ -1239,6 +1320,7 @@ export {
   HELLO_SCHEMA_SWAP_BIT,
   MATCH_CODE_LENGTH,
   MAX_AWAKE_MAX,
+  MSG_KIND_TYPED,
   NATIVE_RESERVE_FRACTION,
   PHYSICS_HEADROOM_MIB,
   PRESENCE_COLLECTION,
@@ -1299,6 +1381,7 @@ export {
   isMailboxAlarm,
   isOutboxAlarm,
   isRelayHash8,
+  isTypedMsg,
   isVoiceMsg,
   mergeProfiles,
   nativeReserveOf,
@@ -1322,6 +1405,7 @@ export {
   schemaPayload,
   topProfileRows,
   typeFootprintMib,
+  typedMsgFromClientOk,
   vmCpuFor,
   vmSizeFor,
   withBuiltins,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irtio/protocol",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "irtio wire protocol: frames, framing, session payloads, error codes, built-in presence",
   "license": "MIT",
   "publishConfig": {
@@ -20,7 +20,7 @@
     "dist"
   ],
   "dependencies": {
-    "@irtio/schema": "0.6.0"
+    "@irtio/schema": "0.7.0"
   },
   "scripts": {
     "build": "tsup",