@series-inc/rundot-syncplay 5.23.0-beta.7

package/dist/collections.d.ts

@@ -0,0 +1,9 @@
+import type { DeterministicRandom } from './random.js';
+export interface StableIndexedEntry<Value> {
+    readonly id: string;
+    readonly value: Value;
+}
+export declare function stableSortedKeys(record: Readonly<Record<string, unknown>>): readonly string[];
+export declare function stableEntries<Value>(record: Readonly<Record<string, Value>>): readonly StableIndexedEntry<Value>[];
+export declare function createStableIndexedMap<Value>(entries: readonly StableIndexedEntry<Value>[]): ReadonlyMap<string, Value>;
+export declare function deterministicShuffle<Value>(values: readonly Value[], random: DeterministicRandom): readonly Value[];

package/dist/collections.js

@@ -0,0 +1,30 @@
+export function stableSortedKeys(record) {
+    return Object.keys(record).sort(compareStrings);
+}
+export function stableEntries(record) {
+    return stableSortedKeys(record).map((id) => ({ id, value: record[id] }));
+}
+export function createStableIndexedMap(entries) {
+    const sorted = [...entries].sort((left, right) => compareStrings(left.id, right.id));
+    const result = new Map();
+    for (const entry of sorted) {
+        if (result.has(entry.id)) {
+            throw new Error(`Duplicate stable id ${entry.id}`);
+        }
+        result.set(entry.id, entry.value);
+    }
+    return result;
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+export function deterministicShuffle(values, random) {
+    const result = values.slice();
+    for (let index = result.length - 1; index > 0; index -= 1) {
+        const swapIndex = random.nextInt(0, index);
+        const value = result[index];
+        result[index] = result[swapIndex];
+        result[swapIndex] = value;
+    }
+    return result;
+}

package/dist/collision.d.ts

@@ -0,0 +1,25 @@
+export type FixedVec2 = {
+    readonly x: number;
+    readonly y: number;
+};
+export type FixedAabb = {
+    readonly minX: number;
+    readonly minY: number;
+    readonly maxX: number;
+    readonly maxY: number;
+};
+export type FixedCircle = {
+    readonly center: FixedVec2;
+    readonly radius: number;
+};
+export declare function fixedVec2(x: number, y: number): FixedVec2;
+export declare function fixedAabb(center: FixedVec2, halfWidth: number, halfHeight: number): FixedAabb;
+export declare function fixedCircle(center: FixedVec2, radius: number): FixedCircle;
+export declare function aabbIntersects(left: FixedAabb, right: FixedAabb): boolean;
+export declare function aabbContainsPoint(aabb: FixedAabb, point: FixedVec2): boolean;
+export declare function circleIntersects(left: FixedCircle, right: FixedCircle): boolean;
+export declare function circleIntersectsAabb(circle: FixedCircle, aabb: FixedAabb): boolean;
+export declare function translateAabb(aabb: FixedAabb, delta: FixedVec2): FixedAabb;
+export declare function sortAabbsByStableId<T extends {
+    readonly id: string;
+}>(items: readonly T[]): readonly T[];

package/dist/collision.js

@@ -0,0 +1,85 @@
+export function fixedVec2(x, y) {
+    assertInteger(x, 'x');
+    assertInteger(y, 'y');
+    return { x, y };
+}
+export function fixedAabb(center, halfWidth, halfHeight) {
+    assertInteger(halfWidth, 'halfWidth');
+    assertInteger(halfHeight, 'halfHeight');
+    if (halfWidth < 0 || halfHeight < 0) {
+        throw new Error('AABB half extents must be non-negative');
+    }
+    return {
+        minX: center.x - halfWidth,
+        minY: center.y - halfHeight,
+        maxX: center.x + halfWidth,
+        maxY: center.y + halfHeight,
+    };
+}
+export function fixedCircle(center, radius) {
+    assertInteger(radius, 'radius');
+    if (radius < 0) {
+        throw new Error('Circle radius must be non-negative');
+    }
+    return { center, radius };
+}
+export function aabbIntersects(left, right) {
+    return left.minX < right.maxX && left.maxX > right.minX && left.minY < right.maxY && left.maxY > right.minY;
+}
+export function aabbContainsPoint(aabb, point) {
+    return point.x >= aabb.minX && point.x <= aabb.maxX && point.y >= aabb.minY && point.y <= aabb.maxY;
+}
+export function circleIntersects(left, right) {
+    const dx = left.center.x - right.center.x;
+    const dy = left.center.y - right.center.y;
+    const radius = left.radius + right.radius;
+    return dx * dx + dy * dy < radius * radius;
+}
+export function circleIntersectsAabb(circle, aabb) {
+    const center = circle.center;
+    const closestPoint = closestPointOnAabb(center, aabb);
+    const delta = {
+        x: center.x - closestPoint.x,
+        y: center.y - closestPoint.y,
+    };
+    return delta.x * delta.x + delta.y * delta.y < circle.radius * circle.radius;
+}
+export function translateAabb(aabb, delta) {
+    return {
+        minX: aabb.minX + delta.x,
+        minY: aabb.minY + delta.y,
+        maxX: aabb.maxX + delta.x,
+        maxY: aabb.maxY + delta.y,
+    };
+}
+export function sortAabbsByStableId(items) {
+    return [...items].sort((left, right) => {
+        if (left.id < right.id) {
+            return -1;
+        }
+        if (left.id > right.id) {
+            return 1;
+        }
+        return 0;
+    });
+}
+function clampToRange(value, min, max) {
+    if (value < min) {
+        return min;
+    }
+    if (value > max) {
+        return max;
+    }
+    return value;
+}
+function closestPointOnAabb(point, aabb) {
+    return {
+        x: clampToRange(point.x, aabb.minX, aabb.maxX),
+        y: clampToRange(point.y, aabb.minY, aabb.maxY),
+    };
+}
+function assertInteger(value, name) {
+    if (!Number.isInteger(value)) {
+        throw new Error(`${name} must be an integer fixed-point value`);
+    }
+}

package/dist/commands.d.ts

@@ -0,0 +1,137 @@
+import { type CanonicalValue } from './canonical.js';
+import type { SchemaFieldKind } from './schema.js';
+export type DeterministicPayloadFieldKind = SchemaFieldKind | `${SchemaFieldKind}[]` | 'object' | 'object[]';
+export interface DeterministicPayloadFieldDescriptor {
+    readonly name: string;
+    readonly kind: DeterministicPayloadFieldKind;
+    readonly min?: number;
+    readonly max?: number;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly optional?: boolean;
+    readonly fields?: readonly DeterministicPayloadFieldDescriptor[];
+}
+export interface DeterministicCommandChannelDescriptor {
+    readonly id: string;
+    readonly maxPayloadBytes: number;
+    readonly reliable: boolean;
+    readonly allowPrediction: boolean;
+    readonly minFrameLead?: number;
+    readonly maxFrameLead?: number;
+    readonly fields?: readonly DeterministicPayloadFieldDescriptor[];
+}
+export interface DeterministicPlayerCommand {
+    readonly id: string;
+    readonly slot: number;
+    readonly frame: number;
+    readonly channelId: string;
+    readonly payload: CanonicalValue;
+    readonly predicted?: boolean;
+    readonly submittedFrame?: number;
+}
+export interface DeterministicRejectedCommand {
+    readonly commandId: string;
+    readonly reason: 'unauthorized-slot' | 'stale-frame' | 'future-frame' | 'oversized-payload' | 'bad-schema' | 'bad-asset-ref' | 'duplicate-command-id' | 'duplicate-slot-frame-command' | 'unknown-channel' | 'insufficient-frame-lead' | 'prediction-not-allowed';
+}
+export interface DeterministicCommandTimelineSnapshot {
+    readonly currentFrame: number;
+    readonly accepted: readonly DeterministicPlayerCommand[];
+    readonly rejected: readonly DeterministicRejectedCommand[];
+    readonly checksum: string;
+}
+export interface DeterministicCommandTimeline {
+    readonly accepted: readonly DeterministicPlayerCommand[];
+    readonly rejected: readonly DeterministicRejectedCommand[];
+    readonly currentFrame: number;
+    setCurrentFrame(frame: number): void;
+    record(command: DeterministicPlayerCommand): DeterministicRejectedCommand | undefined;
+    recordFromSlot(senderSlot: number, command: DeterministicPlayerCommand): DeterministicRejectedCommand | undefined;
+    poll(frame: number, slot?: number, channelId?: string): readonly DeterministicPlayerCommand[];
+    snapshot(): DeterministicCommandTimelineSnapshot;
+    restore(snapshot: DeterministicCommandTimelineSnapshot): void;
+    checksum(): string;
+}
+export interface DeterministicCommandTimelineConfig {
+    readonly playerCount: number;
+    readonly currentFrame: number;
+    readonly channels: readonly DeterministicCommandChannelDescriptor[];
+    readonly validAssetRefs?: readonly string[];
+    readonly validatePayload?: (command: DeterministicPlayerCommand) => boolean;
+}
+export interface DeterministicCommandProtocolMetrics {
+    readonly checksum: string;
+    readonly delivered: number;
+    readonly rejected: number;
+    readonly duplicateDrops: number;
+    readonly multiCommandSameFrameAccepted: number;
+    readonly multiCommandPollOrderStable: boolean;
+    readonly acceptedFutureCommands: number;
+    readonly replayedFutureCommands: number;
+    readonly reliableDelivered: number;
+    readonly reliableResent: number;
+    readonly unreliableDropped: number;
+    readonly reliableOrderingStable: boolean;
+    readonly firstDeliveredFrame: number;
+    readonly lastDeliveredFrame: number;
+    readonly delayP50Frames: number;
+    readonly delayP95Frames: number;
+    readonly rollbackDepthP95: number;
+    readonly schemaRejected: number;
+    readonly schemaDeclaredPayloadsCovered: boolean;
+    readonly schemaCollectionPayloadsCovered: boolean;
+    readonly convergence: boolean;
+}
+export interface DeterministicReliableCommandDefaultsMetrics {
+    readonly checksum: string;
+    readonly players: number;
+    readonly frames: number;
+    readonly accepted: number;
+    readonly reliableDelivered: number;
+    readonly reliableResent: number;
+    readonly unreliableDropped: number;
+    readonly duplicateRejected: number;
+    readonly staleRejected: number;
+    readonly futureRejected: number;
+    readonly pollOrderStable: boolean;
+    readonly replayConverged: boolean;
+    readonly originalOrderHash: string;
+    readonly replayOrderHash: string;
+}
+export interface DeterministicCommandTimelineMigrationMetrics {
+    readonly result: 'pass' | 'fail';
+    readonly players: number;
+    readonly acceptedBeforeMigration: number;
+    readonly acceptedAfterMigration: number;
+    readonly snapshotChecksum: string;
+    readonly restoredChecksum: string;
+    readonly finalChecksum: string;
+    readonly pollOrderStable: boolean;
+    readonly acceptedCommandIdsRestored: boolean;
+    readonly currentFrameRestored: boolean;
+    readonly duplicateAfterRestoreRejected: boolean;
+    readonly staleAfterRestoreRejected: boolean;
+    readonly futureAfterRestoreRejected: boolean;
+    readonly unauthorizedAfterRestoreRejected: boolean;
+    readonly oversizedAfterRestoreRejected: boolean;
+    readonly badSchemaAfterRestoreRejected: boolean;
+    readonly badAssetRefAfterRestoreRejected: boolean;
+    readonly newCommandAcceptedAfterRestore: boolean;
+    readonly rejectionCounts: Readonly<Record<string, number>>;
+    readonly checksum: string;
+}
+export interface DeterministicCommandTimelineMigrationResultInput {
+    readonly invariantChecks: readonly boolean[];
+    readonly snapshotChecksum: string;
+    readonly restoredChecksum: string;
+    readonly acceptedBeforeMigration: number;
+    readonly acceptedAfterMigration: number;
+    readonly expectedAcceptedBeforeMigration: number;
+}
+export declare function createDeterministicCommandTimeline(config: DeterministicCommandTimelineConfig): DeterministicCommandTimeline;
+export declare function runDeterministicCommandTimelineMigrationFixture(players: number): DeterministicCommandTimelineMigrationMetrics;
+export declare function evaluateDeterministicCommandTimelineMigrationResult(input: DeterministicCommandTimelineMigrationResultInput): 'pass' | 'fail';
+export declare function createDeterministicCommandTimelineSnapshot(snapshot: Omit<DeterministicCommandTimelineSnapshot, 'checksum'>): DeterministicCommandTimelineSnapshot;
+export declare function runDeterministicCommandProtocolFixture(players: number, frames: number, seed: number): DeterministicCommandProtocolMetrics;
+export declare function runDeterministicReliableCommandDefaultsFixture(players: number, frames: number, seed: number): DeterministicReliableCommandDefaultsMetrics;
+export declare function deterministicPayloadMatchesFields(payload: CanonicalValue, fields: readonly DeterministicPayloadFieldDescriptor[]): boolean;
+export declare function assertDeterministicPayloadFields(label: string, payload: CanonicalValue, fields: readonly DeterministicPayloadFieldDescriptor[]): void;