@flighthq/entity 0.3.1-next.625.675880d → 0.3.1-next.704.69286f6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flighthq/entity",
-  "version": "0.3.1-next.625.675880d",
+  "version": "0.3.1-next.704.69286f6",
   "author": "Joshua Granick and other contributors",
   "license": "MIT",
   "repository": {
@@ -38,8 +38,8 @@
     "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
   },
   "dependencies": {
-    "@flighthq/log": "0.3.1-next.625.675880d",
-    "@flighthq/types": "0.3.1-next.625.675880d"
+    "@flighthq/log": "0.3.1-next.704.69286f6",
+    "@flighthq/types": "0.3.1-next.704.69286f6"
   },
   "devDependencies": {
     "typescript": "^5.3.0"

package/src/binding.test.ts

@@ -18,6 +18,18 @@ describe('attachEntityBinding', () => {
     attachEntityBinding(entity, binding);
     expect(getEntityRuntime(entity).binding).toStrictEqual(binding);
   });
+
+  it('preserves an existing runtime while assigning its binding', () => {
+    const entity = createEntity();
+    const runtime = createEntityRuntime();
+    const binding = {};
+    entity[EntityRuntimeKey] = runtime;
+
+    attachEntityBinding(entity, binding);
+
+    expect(getEntityRuntime(entity)).toBe(runtime);
+    expect(runtime.binding).toBe(binding);
+  });
 });
 
 describe('getEntityBinding', () => {

package/src/guards.test.ts

@@ -45,6 +45,41 @@ describe('setEntityRuntimeGuardMode', () => {
     }
     expect(areEntityRuntimeGuardsEnabled()).toBe(false);
   });
+
+  it('stays disabled when Proxy is unavailable', () => {
+    const originalProxy = globalThis.Proxy;
+    let enabled: boolean;
+    Object.defineProperty(globalThis, 'Proxy', { configurable: true, value: undefined, writable: true });
+    try {
+      setEntityRuntimeGuardMode(true);
+      enabled = areEntityRuntimeGuardsEnabled();
+    } finally {
+      Object.defineProperty(globalThis, 'Proxy', { configurable: true, value: originalProxy, writable: true });
+      setEntityRuntimeGuardMode(false);
+    }
+
+    expect(enabled!).toBe(false);
+  });
+
+  it('returns the original values when Proxy disappears after guards are enabled', () => {
+    const entity = createEntity({ x: 1 });
+    const runtime = createEntityRuntime();
+    const originalProxy = globalThis.Proxy;
+    let guardedEntity: typeof entity;
+    let guardedRuntime: typeof runtime;
+    setEntityRuntimeGuardMode(true);
+    Object.defineProperty(globalThis, 'Proxy', { configurable: true, value: undefined, writable: true });
+    try {
+      guardedEntity = createGuardedEntity(entity);
+      guardedRuntime = createGuardedEntityRuntime(runtime);
+    } finally {
+      Object.defineProperty(globalThis, 'Proxy', { configurable: true, value: originalProxy, writable: true });
+      setEntityRuntimeGuardMode(false);
+    }
+
+    expect(guardedEntity!).toBe(entity);
+    expect(guardedRuntime!).toBe(runtime);
+  });
 });
 
 describe('setEntityRuntimeWriteGuard', () => {
@@ -78,4 +113,42 @@ describe('setEntityRuntimeWriteGuard', () => {
       setEntityRuntimeGuardMode(false);
     }
   });
+
+  it('ignores writes to ordinary properties', () => {
+    const slots: EntityRuntimeWriteSlot[] = [];
+    setEntityRuntimeGuardMode(true);
+    setEntityRuntimeWriteGuard((slot) => slots.push(slot));
+    try {
+      const guardedEntity = createGuardedEntity(createEntity({ x: 1 }));
+      guardedEntity.x = 2;
+      const guardedRuntime = createGuardedEntityRuntime(createEntityRuntime()) as ReturnType<
+        typeof createEntityRuntime
+      > & { other?: number };
+      guardedRuntime.other = 3;
+      expect(guardedEntity.x).toBe(2);
+      expect(guardedRuntime.other).toBe(3);
+      expect(slots).toEqual([]);
+    } finally {
+      setEntityRuntimeWriteGuard(null);
+      setEntityRuntimeGuardMode(false);
+    }
+  });
+
+  it('keeps existing proxies silent after guard mode is disabled', () => {
+    const slots: EntityRuntimeWriteSlot[] = [];
+    setEntityRuntimeGuardMode(true);
+    setEntityRuntimeWriteGuard((slot) => slots.push(slot));
+    const guardedEntity = createGuardedEntity(createEntity());
+    const guardedRuntime = createGuardedEntityRuntime(createEntityRuntime());
+    setEntityRuntimeGuardMode(false);
+    try {
+      guardedEntity[EntityRuntimeKey] = undefined;
+      guardedRuntime.binding = {};
+      expect(slots).toEqual([]);
+      expect(guardedRuntime.binding).toEqual({});
+    } finally {
+      setEntityRuntimeWriteGuard(null);
+      setEntityRuntimeGuardMode(false);
+    }
+  });
 });