openrtc-netcode 3.0.0 → 3.0.2

package/README.md

@@ -1,61 +1,202 @@
 # openrtc-netcode
 
-`openrtc-netcode` is a small multiplayer layer on top of OpenRTC. It treats
-OpenRTC rooms as lobbies, observes the runtime-owned P2P mesh between lobby members,
-and exposes reliable typed messages, lightweight replicated state, networked
-objects, and browser voice-chat media.
-
-Gameplay payloads are sent over OpenRTC peer data paths only: Iroh
-relay/direct plus WebRTC or MoQ custom Iroh carriers when enabled. Live
-membership and signaling use the OpenRTC coordination gateway; neither core
-netcode nor its payload path uses Firebase, Firestore, or RTDB.
-
-`preferredTransports` filters OpenRTC's typed application-readiness
-query; it does not request promotion. OpenRTC owns optional transport promotion
-and recovery, while netcode only observes route events. Netcode consumes one
-already-activated room handle, so it never retains an unused user or space
-avenue.
+Multiplayer state and simulation primitives over an activated OpenRTC room.
+The adapter observes `Room.members` for membership; `Room.peers` remains a
+retained lifecycle projection and is not used as a match roster. Netcode peer
+IDs are the current node bindings in that roster; device-only sparse entries
+are not fabricated into routable game peers. Use a small mesh or an admitted
+authority topology whose required game peers have routes.
+OpenRTC owns authenticated membership, logical connections, admission, carriers
+and recovery. Netcode owns game protocol, authority, replication and actions;
+it never dials peers or installs connection repair timers.
+
+This source implements **wire v2**, intended for the coordinated 3.0.0 train.
+It is not compatible with published v1 peers (including 2.9.7/2.9.8). Upgrade a
+whole match together. `protocol:error` reports incompatible frames and
+`waitForPeer()` rejects incompatible negotiation or timeout. Package versions
+remain unchanged until the complete release train qualifies; see the repository
+netcode audit's release-readiness record. No new release is implied by this file.
 
 ```ts
 import { OpenRTC } from 'openrtc';
 import { createNetcode } from 'openrtc-netcode';
 
-const rtc = OpenRTC({
-  apiKey: 'pk_live_...',
-  transports: { webrtc: true },
+const rtc = OpenRTC({ apiKey: 'pk_live_...', transports: { webrtc: true } });
+const room = await rtc.rooms.join('match', {
+  access: 'capability', membership: 'ephemeral', maxPeers: 8,
 });
-const room = await rtc.rooms.join('duel-room', {
-  access: 'capability',
-  membership: 'ephemeral',
+const game = createNetcode({
+  room, tickRate: 60, codec: 'quantized',
+  authority: { mode: 'owner', hostOwnedKinds: ['crate'] },
+  replication: { bytesPerSecond: 96 * 1024, maxStateAgeMs: 250 },
+  motionThresholds: { position: 0.002, rotationRadians: 0.002, maxSilenceMs: 1000 },
 });
-const netcode = createNetcode({ room });
-await netcode.joinLobby('duel-room');
-
-netcode.onMessage('chat', (message) => {
-  console.log(message.from, message.payload);
+game.on('protocol:error', ({ peerId, reason }) => console.warn(peerId, reason));
+await game.joinLobby(room.id);
+const player = await game.objects.spawn({
+  kind: 'player', transform: { position: { x: 0, y: 1, z: 0 } },
 });
-
-await netcode.broadcast('chat', { text: 'hello' });
 ```
 
-Networked game objects are synchronized through `netcode.objects`:
+## Authority and lifetime
+
+`mode: 'owner'` permits each peer to publish its own objects and NetVars.
+Give each NetVar key one agreed owner; namespace per-player keys by peer ID.
+Declaring the same default-local key independently on several peers does not
+create shared write authority. Use
+this for cooperative worlds whose players are trusted to control their avatars.
+`hostOwnedKinds` restricts shared physics kinds to the current host.
+`mode: 'host'` restricts every object and NetVar writer to the host; clients send
+validated actions or inputs to that host. A trusted dedicated Node authority is
+appropriate for competitive rules. Encryption authenticates a writer; application
+handlers must still validate speed, reach, cooldowns, resources and game rules.
+
+Without `hostId`, the host is the lexicographically smallest current member ID,
+including the local peer. A joining lower ID can therefore change the host.
+A host change retires old host-owned entities and, in host mode, old host NetVars;
+the new host initializes its scene/state. This is a reset policy, not seamless
+physics migration. Authenticated hello epochs fence delayed host packets, and
+host-owned objects receive a fresh incarnation when authority resets. Pending
+actions to a retired authority reject with an unknown effect outcome. Stable
+action IDs and receipt windows remain valid for unchanged recipients in the
+same peer session. Suspended producers cannot publish into a later authority
+period. Receipts echo the original action sequence; delayed results cannot
+settle a later request that reuses a stable ID after recipient retirement.
+Pin the same admitted `hostId` on every client when continuity
+requires a designated authority. If that peer leaves, choose a new match or
+explicit application migration; this library does not appoint an impersonator.
+`owner: 'lobby-owner'` on an owner-mode NetVar binds the current host.
+Declarations made before joining bind when the first host is resolved; they
+then stay bound to that peer. Remote placeholders do not compete with the
+authoritative owner's initial revision.
+
+Object IDs are always owner-prefixed (`${peerId}:...`). Omit `id` for a generated
+ID containing a random store instance. Ownership transfer is unsupported.
+Writers cannot supply `revision` or `incarnation`; every mutation increments a
+safe-integer revision. The match session fences old owner incarnations; host-owned kinds also bind
+their incarnation to the authenticated authority epoch. `tick`
+is simulation time; `updatedAt` is informational and never orders mutations.
+Equal revisions use canonical JSON order; removal wins an equal-version tie.
+Unapproved mutations produce no accepted-state events.
+
+Live entities and deletion versions share a 10,000-ID lifetime bound and 7 MiB serialized byte budget per store; an entry
+may not exceed 220 KiB. NetVars have 4096 keys, 4 MiB total and 240 KiB per value.
+Retain tombstones until match retirement to prevent stale resurrection. Exhaustion
+rejects explicitly; start a new match rather than evicting deletion authority.
+Authoritative peer departure retires that peer's entities, state and receipts.
+Leaving resets match data and rejects queued work. Old NetVar handles reject;
+define a new handle in the next match. `stop()` releases netcode observers,
+channels and microphone ownership; it does not stop a borrowed OpenRTC runtime.
+After leaving a borrowed Room, activate a fresh Room capability before reusing it.
+
+## Simulation and rendering
 
 ```ts
-await netcode.objects.spawn({
-  id: 'crate-1',
-  kind: 'crate',
-  transform: { position: { x: 0, y: 1, z: 0 } },
-  physics: { linearVelocity: { x: 0, y: 0, z: 0 } },
+import { SnapshotBuffer, InputPrediction, LagHistory } from 'openrtc-netcode';
+
+// Drive from the engine's fixed simulation loop, independently of rendering.
+game.clock.advance(frameDeltaSeconds, (_tick, fixedDelta) => simulate(fixedDelta));
+game.flushReplication();
+
+const buffer = new SnapshotBuffer({ tickRate: 60, hermite: true });
+const object = game.objects.read(player.id); // deeply frozen; no clone allocation
+if (object) buffer.push({
+  epoch: object.incarnation, tick: object.tick, revision: object.revision,
+  transform: object.transform, linearVelocity: object.physics?.linearVelocity,
+  teleport: object.teleport,
 });
+buffer.sample(performance.now() / 1000, pooledTransform);
 ```
 
-Voice chat publishes microphone tracks through each already-established
-OpenRTC logical connection. Netcode does not create a second peer connection,
-exchange SDP/ICE, or own transport recovery:
+Push each accepted entity revision once. Buffers estimate arrival offset and
+jitter, interpolate authoritative ticks with linear/Hermite position and
+quaternion slerp, and cap extrapolation (120 ms by default). Epoch changes and
+teleports reset interpolation; retired epochs cannot restore old poses. Use
+monotonic arrival time, never sender wall time. Sleeping/teleport flags are
+explicit. The fixed clock caps catch-up to eight ticks and records dropped ticks.
+
+`InputPrediction<State, Input>` stores bounded sequenced inputs; `reconcile()`
+applies an authoritative acknowledged sequence and replays only pending inputs.
+Supply the deterministic movement step and reset at authority epochs. It does
+not make arbitrary rigid-body engines deterministic or provide anti-cheat.
+`LagHistory<State>` retains bounded authoritative ticks for game-owned rewind
+queries, rejects out-of-window requests, and never accepts a client's claimed
+hit as authority. Clamp rewind to your measured latency and game policy.
+
+Read entity IDs with `objects.ids(kind)` and poses with `objects.read(id)` from
+the render loop. `get/list/snapshot` clone for general application use; avoid
+calling them for every entity every rendered frame. React consumers should use
+`useNetworkObjectIds` and imperative pose reads. Single-entity and small
+collection hooks remain available for ordinary UI.
+
+## Replication, interest and receipts
+
+Each peer has its own motion queue: one in-flight batch, one pending value per
+entity, token budget, priority and state expiry. A blocked peer does not stall
+other recipients. Call `flushReplication()` from the game loop to replenish
+budgets/expire pending state. `replicationStats(peerId)` exposes bytes, age,
+supersession and expiry. Successful motion submission can mean replacement or
+expiry; it is not an application acknowledgement. There is no retry/redial timer.
+
+`interest(peerId, object)` controls the exact reliable view sent to each peer;
+call `refreshInterest()` after an interest-only change. Snapshots are bounded
+pages applied atomically, and motion is bound to a view revision. Interest hides
+entities; it does not grant authority. Avoid expensive all-world scans in an
+interest callback; use your spatial index and relevant peer region.
+`priority(peerId, object)` affects budget selection. Optional motion thresholds
+suppress tiny changes relative to the last transmitted pose, with a max-silence
+refresh when the application next publishes. Static metadata/scale changes and
+teleports still replicate. Defaults are bounded, not universal game tuning.
+
+The JSON codec sends lossless indexed moving fields. Both codecs keep static
+identity, metadata and scale in the reliable baseline. The quantized codec sends 59-byte motion records
+plus a 5-byte header (64 bytes for one object), before base64/envelope/transport
+overhead. Positions use millimetres (about ±2,147 km), velocities centi-units
+(about ±327 units/s), and normalized quaternion components use int16. Out-of-range
+values reject; choose JSON for larger ranges. Reliable baselines carry static
+metadata and scale. Batches contain at most 1,024 records, frames at most 256 KiB,
+and assembled snapshots at most 8 MiB. No binary delta depends on an unacknowledged
+previous motion packet. The Rust crate validates JSON envelopes; its packed
+motion field is opaque rather than a second binary implementation.
 
 ```ts
-await netcode.voice.start();
-netcode.voice.on('peer:stream', ({ stream }) => {
-  audioElement.srcObject = stream;
+game.handleAction('crate:interact', (payload, { from, signal }) => {
+  if (signal.aborted) throw new Error('Retired match');
+  validateReachAndCooldown(from, payload);
+  return applyAuthoritativeImpulse(payload);
+});
+const receipt = await game.request(hostId, 'crate:interact', { crateId }, {
+  id: 'immutable-input-123', timeoutMs: 5000,
 });
 ```
+
+Action receipts acknowledge the handler result. A timeout means the outcome is
+unknown: reuse the same immutable stable ID to query a retained result, never
+invent a new ID to retry an uncertain effect. Generated action IDs continue in
+long matches. Sequences have a 256-action window per authenticated sender
+session; expired or evicted results reject without replaying the effect. At most
+256 custom stable IDs are retained per caller match. Active effects are capped
+at 8 per peer/64 globally; payload/result limits are 16 KiB and full receipt data
+is capped at 4 MiB. Handlers must honor their AbortSignal; the library cannot undo
+external side effects. No durable exactly-once guarantee spans process loss.
+
+Reliable control and replaceable motion use distinct logical channels.
+Targeted actions also bind the recipient session so a delayed request cannot
+execute against a restarted peer. `send()`/`broadcast()` use reliable control delivery and reject missing routes;
+they acknowledge transport submission, not a gameplay effect. Voice adds tracks
+to existing logical connections and fences late microphone capture on stop.
+BroadcastChannel fallback was removed because it could forge authenticated
+peer identity. Test local games through a real explicit OpenRTC emulator lane.
+
+## Technique references and qualification
+
+The chosen separation of fixed simulation, authoritative physics, delayed
+interpolation and bounded extrapolation follows the documented approaches in
+[Unity authoritative physics](https://docs-multiplayer.unity3d.com/netcode/1.8.1/advanced-topics/physics/),
+[Unity interpolation](https://docs.unity.cn/Packages/com.unity.netcode.gameobjects%402.13/manual/learn/clientside-interpolation.html),
+and [Valve networking](https://developer.valvesoftware.com/wiki/Source_Multiplayer_Networking).
+Game genre, authority topology, physical transport and bandwidth determine the
+right rates and budgets. Local fake-runtime tests prove protocol contracts;
+source-built browsers, native hosts, real networks and adverse-load measurements
+are separate qualification. Reliable carriers can still have transport-level
+head-of-line latency; application coalescing does not turn them into datagrams.

package/dist/actions.d.ts

@@ -0,0 +1,40 @@
+export interface ActionContext {
+    from: string;
+    id: string;
+    sessionId: string;
+    signal: AbortSignal;
+}
+export type ActionHandler = (payload: unknown, context: ActionContext) => unknown | Promise<unknown>;
+/** Match-scoped, bounded action receipts and idempotent effects. No redial/retry. */
+export declare class ActionRegistry {
+    private readonly send;
+    private readonly handlers;
+    private readonly pending;
+    private readonly receipts;
+    private receiptBytes;
+    private active;
+    private readonly activeByPeer;
+    private readonly controllers;
+    private sequence;
+    private readonly stableRequests;
+    private readonly receiptWindows;
+    constructor(send: (peerId: string, kind: 'action' | 'action.receipt', body: unknown) => Promise<void>);
+    handle(type: string, handler: ActionHandler): () => void;
+    request(peerId: string, type: string, payload: unknown, options?: {
+        id?: string;
+        timeoutMs?: number;
+    }): Promise<unknown>;
+    receive(from: string, sessionId: string, body: unknown): Promise<void>;
+    receiveReceipt(from: string, body: unknown): void;
+    /** Called after the runtime retires a peer or the peer changes session. */
+    removePeer(peerId: string, options?: {
+        preserveReceipts?: boolean;
+    }): void;
+    clear(options?: {
+        preserveOutgoing?: boolean;
+    }): void;
+    private reject;
+    private deliver;
+    private deleteReceipt;
+    private trimReceipts;
+}

package/dist/actions.js

@@ -0,0 +1,269 @@
+import { canonicalJson, cloneJson, isId, isCounter } from './validation.js';
+const MAX_ACTION_BYTES = 16 * 1024;
+const MAX_RECEIPT_BYTES = 4 * 1024 * 1024;
+const encoder = new TextEncoder();
+function actionValue(value) {
+    const clone = cloneJson(value);
+    if (encoder.encode(JSON.stringify(clone)).byteLength > MAX_ACTION_BYTES)
+        throw new Error('Action value exceeds the 16 KiB limit.');
+    return clone;
+}
+/** Match-scoped, bounded action receipts and idempotent effects. No redial/retry. */
+export class ActionRegistry {
+    constructor(send) {
+        this.send = send;
+        this.handlers = new Map();
+        this.pending = new Map();
+        this.receipts = new Map();
+        this.receiptBytes = 0;
+        this.active = 0;
+        this.activeByPeer = new Map();
+        this.controllers = new Map();
+        this.sequence = 0;
+        this.stableRequests = new Map();
+        this.receiptWindows = new Map();
+    }
+    handle(type, handler) {
+        if (!isId(type) || this.handlers.has(type) || this.handlers.size >= 128)
+            throw new Error('Invalid or duplicate action handler.');
+        this.handlers.set(type, handler);
+        return () => { if (this.handlers.get(type) === handler)
+            this.handlers.delete(type); };
+    }
+    request(peerId, type, payload, options = {}) {
+        const id = options.id ?? crypto.randomUUID();
+        const timeoutMs = options.timeoutMs ?? 5000;
+        if (!isId(peerId) || !isId(id) || !isId(type) || !Number.isFinite(timeoutMs) || timeoutMs < 1 || timeoutMs > 60000 || this.pending.size >= 64 || this.pending.has(id)) {
+            return Promise.reject(new Error('Action request limit or identity rejected.'));
+        }
+        let value;
+        try {
+            value = actionValue(payload);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        const identity = canonicalJson([peerId, type, value]);
+        const stable = options.id ? this.stableRequests.get(id) : undefined;
+        if ((stable && stable.identity !== identity) || (options.id && !stable && this.stableRequests.size >= 256) || !isCounter(this.sequence + 1))
+            return Promise.reject(new Error('Stable action identity capacity or content rejected.'));
+        const sequence = stable?.sequence ?? ++this.sequence;
+        if (options.id && !stable)
+            this.stableRequests.set(id, { peerId, sequence, identity });
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                if (this.pending.get(id) !== request)
+                    return;
+                this.pending.delete(id);
+                reject(new Error('Action receipt timed out; effect outcome is unknown.'));
+            }, timeoutMs);
+            const request = { peerId, sequence, resolve, reject, timer };
+            this.pending.set(id, request);
+            void Promise.resolve().then(() => {
+                if (this.pending.get(id) !== request)
+                    return;
+                return this.send(peerId, 'action', { id, type, sequence, payload: value });
+            }).catch((error) => {
+                const pending = this.pending.get(id);
+                if (pending !== request)
+                    return;
+                clearTimeout(pending.timer);
+                this.pending.delete(id);
+                pending.reject(error instanceof Error ? error : new Error(String(error)));
+            });
+        });
+    }
+    async receive(from, sessionId, body) {
+        if (!isId(from) || !isId(sessionId) || !body || typeof body !== 'object')
+            return;
+        const action = body;
+        if (!isId(action.id) || !isId(action.type) || !isCounter(action.sequence) || action.sequence < 1)
+            return;
+        const id = action.id, type = action.type, sequence = action.sequence;
+        const source = JSON.stringify([from, sessionId]);
+        let window = this.receiptWindows.get(source);
+        if (!window) {
+            if (this.receiptWindows.size >= 128) {
+                await this.reject(from, id, sequence, 'Action source capacity exhausted.');
+                return;
+            }
+            window = { peerId: from, high: 0, entries: new Map() };
+            this.receiptWindows.set(source, window);
+        }
+        const key = JSON.stringify([from, sessionId, sequence]);
+        if (sequence <= window.high - 256) {
+            await this.reject(from, id, sequence, 'Action receipt window expired; effect will not be replayed.');
+            return;
+        }
+        if (sequence > window.high) {
+            window.high = sequence;
+            for (const [old, receiptKey] of window.entries)
+                if (old <= sequence - 256) {
+                    this.deleteReceipt(receiptKey);
+                    window.entries.delete(old);
+                }
+        }
+        let payload;
+        try {
+            payload = actionValue(action.payload);
+        }
+        catch {
+            await this.reject(from, id, sequence, 'Action payload exceeds the schema or 16 KiB limit.');
+            return;
+        }
+        const identity = canonicalJson([id, type, payload]);
+        const existing = this.receipts.get(key);
+        if (existing) {
+            if (existing.identity !== identity)
+                await this.reject(from, id, sequence, 'Action identity reused with different content.');
+            else if (!existing.pending)
+                await this.deliver(from, existing, this.controllers.get(from)?.signal);
+            return;
+        }
+        if (window.entries.has(sequence)) {
+            // Byte-budget eviction retains the sequence marker, so a missing
+            // receipt never permits the already completed effect to run again.
+            await this.reject(from, id, sequence, 'Action receipt expired; effect will not be replayed.');
+            return;
+        }
+        if (this.active >= 64 || (this.activeByPeer.get(from) ?? 0) >= 8) {
+            await this.reject(from, id, sequence, 'Action execution capacity exhausted.');
+            return;
+        }
+        let controller = this.controllers.get(from);
+        if (!controller) {
+            controller = new AbortController();
+            this.controllers.set(from, controller);
+        }
+        const signal = controller.signal;
+        const entry = { identity, bytes: encoder.encode(identity).byteLength, pending: true, sending: false };
+        this.receipts.set(key, entry);
+        this.receiptBytes += entry.bytes;
+        window.entries.set(sequence, key);
+        this.active++;
+        this.activeByPeer.set(from, (this.activeByPeer.get(from) ?? 0) + 1);
+        this.trimReceipts();
+        try {
+            if (signal.aborted)
+                throw new Error('Action peer retired.');
+            const handler = this.handlers.get(type);
+            if (!handler)
+                throw new Error('Action is not registered.');
+            const result = await handler(payload, { from, id, sessionId, signal });
+            entry.result = { id, sequence, ok: true, result: actionValue(result === undefined ? null : result) };
+        }
+        catch (error) {
+            entry.result = { id, sequence, ok: false, error: error instanceof Error ? error.message.slice(0, 256) : 'Action rejected.' };
+        }
+        finally {
+            this.active--;
+            const count = (this.activeByPeer.get(from) ?? 1) - 1;
+            if (count)
+                this.activeByPeer.set(from, count);
+            else
+                this.activeByPeer.delete(from);
+            entry.pending = false;
+        }
+        if (this.receipts.get(key) === entry) {
+            const bytes = encoder.encode(JSON.stringify(entry.result)).byteLength;
+            entry.bytes += bytes;
+            this.receiptBytes += bytes;
+            this.trimReceipts();
+        }
+        await this.deliver(from, entry, signal);
+    }
+    receiveReceipt(from, body) {
+        if (!body || typeof body !== 'object')
+            return;
+        const receipt = body;
+        if (!isId(receipt.id) || typeof receipt.ok !== 'boolean')
+            return;
+        const pending = this.pending.get(receipt.id);
+        if (!pending || pending.peerId !== from || receipt.sequence !== pending.sequence)
+            return;
+        let result;
+        if (receipt.ok) {
+            try {
+                result = actionValue(receipt.result);
+            }
+            catch {
+                return;
+            }
+        }
+        clearTimeout(pending.timer);
+        this.pending.delete(receipt.id);
+        if (receipt.ok)
+            pending.resolve(result);
+        else
+            pending.reject(new Error(typeof receipt.error === 'string' ? receipt.error.slice(0, 256) : 'Action rejected.'));
+    }
+    /** Called after the runtime retires a peer or the peer changes session. */
+    removePeer(peerId, options = {}) {
+        if (!options.preserveReceipts) {
+            this.controllers.get(peerId)?.abort();
+            this.controllers.delete(peerId);
+        }
+        for (const [id, pending] of this.pending)
+            if (pending.peerId === peerId) {
+                clearTimeout(pending.timer);
+                this.pending.delete(id);
+                pending.reject(new Error('Action peer retired; effect outcome is unknown.'));
+            }
+        for (const [source, window] of this.receiptWindows)
+            if (!options.preserveReceipts && window.peerId === peerId) {
+                for (const key of window.entries.values())
+                    this.deleteReceipt(key);
+                this.receiptWindows.delete(source);
+            }
+        for (const [id, stable] of this.stableRequests)
+            if (stable.peerId === peerId)
+                this.stableRequests.delete(id);
+    }
+    clear(options = {}) {
+        for (const controller of this.controllers.values())
+            controller.abort();
+        this.controllers.clear();
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error('Action match retired.'));
+        }
+        this.pending.clear();
+        this.receipts.clear();
+        this.receiptBytes = 0;
+        this.receiptWindows.clear();
+        if (!options.preserveOutgoing) {
+            this.stableRequests.clear();
+            this.sequence = 0;
+        }
+        // Keep active slots until settlement even when handlers ignore abort.
+    }
+    reject(peerId, id, sequence, error) {
+        return this.send(peerId, 'action.receipt', { id, sequence, ok: false, error });
+    }
+    async deliver(peerId, entry, signal) {
+        if (!entry.result || entry.sending || !signal || signal.aborted)
+            return;
+        entry.sending = true;
+        try {
+            await this.send(peerId, 'action.receipt', entry.result);
+        }
+        finally {
+            entry.sending = false;
+        }
+    }
+    deleteReceipt(key) {
+        const entry = this.receipts.get(key);
+        if (entry) {
+            this.receiptBytes -= entry.bytes;
+            this.receipts.delete(key);
+        }
+    }
+    trimReceipts() {
+        for (const [key, entry] of this.receipts) {
+            if (this.receiptBytes <= MAX_RECEIPT_BYTES && this.receipts.size <= 2048)
+                break;
+            if (!entry.pending)
+                this.deleteReceipt(key);
+        }
+    }
+}