@dcl/ecs 7.0.5 → 7.0.6-3652441072.commit-39343cb

package/dist/engine/component.d.ts

@@ -50,6 +50,7 @@ export declare type ComponentDefinition<T extends ISchema<ConstructorType>, Cons
      */
     createOrReplace(entity: Entity, val?: ConstructorType): ComponentType<T>;
     /**
+     * @public
      * Delete the current component to an entity, return null if the entity doesn't have the current component.
      * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
      * @param entity - Entity to delete the component from

package/dist/engine/component.js

@@ -36,10 +36,15 @@ export function defineComponent(componentId, spec, constructorDefault
         has(entity) {
             return data.has(entity);
         },
-        deleteFrom(entity) {
+        deleteFrom(entity, markAsDirty = true) {
             const component = data.get(entity);
             data.delete(entity);
-            dirtyIterator.add(entity);
+            if (markAsDirty) {
+                dirtyIterator.add(entity);
+            }
+            else {
+                dirtyIterator.delete(entity);
+            }
             return component || null;
         },
         getOrNull(entity) {
@@ -103,6 +108,15 @@ export function defineComponent(componentId, spec, constructorDefault
             spec.serialize(component, writeBuffer);
             return writeBuffer;
         },
+        toBinaryOrNull(entity) {
+            const component = data.get(entity);
+            if (!component) {
+                return null;
+            }
+            const writeBuffer = createByteBuffer();
+            spec.serialize(component, writeBuffer);
+            return writeBuffer;
+        },
         writeToByteBuffer(entity, buffer) {
             const component = data.get(entity);
             if (!component) {
@@ -110,17 +124,22 @@ export function defineComponent(componentId, spec, constructorDefault
             }
             spec.serialize(component, buffer);
         },
-        updateFromBinary(entity, buffer) {
+        updateFromBinary(entity, buffer, markAsDirty = true) {
             const component = data.get(entity);
             if (!component) {
                 throw new Error(`[updateFromBinary] Component ${componentId} for ${entity} not found`);
             }
-            return this.upsertFromBinary(entity, buffer);
+            return this.upsertFromBinary(entity, buffer, markAsDirty);
         },
-        upsertFromBinary(entity, buffer) {
+        upsertFromBinary(entity, buffer, markAsDirty = true) {
             const newValue = spec.deserialize(buffer);
             data.set(entity, newValue);
-            dirtyIterator.add(entity);
+            if (markAsDirty) {
+                dirtyIterator.add(entity);
+            }
+            else {
+                dirtyIterator.delete(entity);
+            }
             return newValue;
         },
         clearDirty() {

package/dist/engine/index.js

@@ -33,6 +33,14 @@ function preEngine() {
         }
         return entityContainer.removeEntity(entity);
     }
+    function registerCustomComponent(component, componentId) {
+        const prev = componentsDefinition.get(componentId);
+        if (prev) {
+            throw new Error(`Component number ${componentId} was already registered.`);
+        }
+        componentsDefinition.set(componentId, component);
+        return component;
+    }
     function defineComponentFromSchema(spec, componentId, constructorDefault) {
         const prev = componentsDefinition.get(componentId);
         if (prev) {
@@ -84,6 +92,24 @@ function preEngine() {
     function removeComponentDefinition(componentId) {
         componentsDefinition.delete(componentId);
     }
+    const Transform = components.Transform({ defineComponentFromSchema });
+    function* getTreeEntityArray(firstEntity, proccesedEntities) {
+        // This avoid infinite loop when there is a cyclic parenting
+        if (proccesedEntities.find((value) => firstEntity === value))
+            return;
+        proccesedEntities.push(firstEntity);
+        for (const [entity, value] of getEntitiesWith(Transform)) {
+            if (value.parent === firstEntity) {
+                yield* getTreeEntityArray(entity, proccesedEntities);
+            }
+        }
+        yield firstEntity;
+    }
+    function removeEntityWithChildren(firstEntity) {
+        for (const entity of getTreeEntityArray(firstEntity, [])) {
+            removeEntity(entity);
+        }
+    }
     return {
         entityExists,
         componentsDefinition,
@@ -97,7 +123,9 @@ function preEngine() {
         getEntitiesWith,
         getComponent,
         getComponentOrNull,
-        removeComponentDefinition
+        removeComponentDefinition,
+        removeEntityWithChildren,
+        registerCustomComponent
     };
 }
 /**
@@ -106,55 +134,27 @@ function preEngine() {
 export function Engine() {
     const engine = preEngine();
     const crdtSystem = crdtSceneSystem(engine);
-    function update(dt) {
-        crdtSystem.receiveMessages();
+    async function update(dt) {
+        await crdtSystem.receiveMessages();
         for (const system of engine.getSystems()) {
             const ret = system.fn(dt);
             checkNotThenable(ret, `A system (${system.name || 'anonymous'}) returned a thenable. Systems cannot be async functions. Documentation: https://dcl.gg/sdk/sync-systems`);
         }
-        // TODO: Perf tip
-        // Should we add some dirtyIteratorSet at engine level so we dont have
-        // to iterate all the component definitions to get the dirty ones ?
-        const dirtySet = new Map();
-        for (const [componentId, definition] of engine.componentsDefinition) {
-            for (const entity of definition.dirtyIterator()) {
-                if (!dirtySet.has(entity)) {
-                    dirtySet.set(entity, new Set());
-                }
-                dirtySet.get(entity).add(componentId);
-            }
-        }
-        crdtSystem.createMessages(dirtySet);
+        const dirtyEntities = crdtSystem.updateState();
+        await crdtSystem.sendMessages(dirtyEntities);
         for (const [_componentId, definition] of engine.componentsDefinition) {
             definition.clearDirty();
         }
     }
-    const Transform = components.Transform(engine);
-    function* getTreeEntityArray(firstEntity, proccesedEntities) {
-        // This avoid infinite loop when there is a cyclic parenting
-        if (proccesedEntities.find((value) => firstEntity === value))
-            return;
-        proccesedEntities.push(firstEntity);
-        for (const [entity, value] of engine.getEntitiesWith(Transform)) {
-            if (value.parent === firstEntity) {
-                yield* getTreeEntityArray(entity, proccesedEntities);
-            }
-        }
-        yield firstEntity;
-    }
-    function removeEntityWithChildren(firstEntity) {
-        for (const entity of getTreeEntityArray(firstEntity, [])) {
-            engine.removeEntity(entity);
-        }
-    }
     return {
         addEntity: engine.addEntity,
         removeEntity: engine.removeEntity,
-        removeEntityWithChildren,
+        removeEntityWithChildren: engine.removeEntityWithChildren,
         addSystem: engine.addSystem,
         removeSystem: engine.removeSystem,
         defineComponent: engine.defineComponent,
         defineComponentFromSchema: engine.defineComponentFromSchema,
+        registerCustomComponent: engine.registerCustomComponent,
         getEntitiesWith: engine.getEntitiesWith,
         getComponent: engine.getComponent,
         getComponentOrNull: engine.getComponentOrNull,
@@ -164,6 +164,8 @@ export function Engine() {
         PlayerEntity: 1,
         CameraEntity: 2,
         entityExists: engine.entityExists,
-        addTransport: crdtSystem.addTransport
+        addTransport: crdtSystem.addTransport,
+        getCrdtState: crdtSystem.getCrdt,
+        componentsDefinition: engine.componentsDefinition
     };
 }

package/dist/engine/types.d.ts

@@ -1,7 +1,7 @@
 import type { ISchema } from '../schemas/ISchema';
 import { Result, Spec } from '../schemas/Map';
 import { Transport } from '../systems/crdt/types';
-import { ComponentDefinition as CompDef } from './component';
+import { ComponentDefinition } from './component';
 import { Entity } from './entity';
 import { SystemFn } from './systems';
 import { ReadonlyComponentSchema } from './readonly';
@@ -13,8 +13,8 @@ export declare type Unpacked<T> = T extends (infer U)[] ? U : T;
 /**
  * @public
  */
-export declare type ComponentSchema<T extends [CompDef<any>, ...CompDef<any>[]]> = {
-    [K in keyof T]: T[K] extends CompDef<any> ? ReturnType<T[K]['getMutable']> : never;
+export declare type ComponentSchema<T extends [ComponentDefinition<any>, ...ComponentDefinition<any>[]]> = {
+    [K in keyof T]: T[K] extends ComponentDefinition<any> ? ReturnType<T[K]['getMutable']> : never;
 };
 /**
  * @public
@@ -66,6 +66,12 @@ export declare type IEngine = {
      * @returns if it was found and removed
      */
     removeSystem(selector: string | SystemFn): boolean;
+    /**
+     * Registers a custom component definition.
+     * @param component - The component definition
+     * @param componentId - unique id to identify the component, if the component id already exist, it will fail.
+     */
+    registerCustomComponent<T extends ISchema, V>(component: ComponentDefinition<T, V>, componentId: number): ComponentDefinition<T, V>;
     /**
      * Define a component and add it to the engine.
      * @param spec - An object with schema fields
@@ -82,7 +88,7 @@ export declare type IEngine = {
      *
      * ```
      */
-    defineComponent<T extends Spec, ConstructorType = Partial<Result<T>>>(spec: T, componentId: number, constructorDefault?: ConstructorType): CompDef<ISchema<Result<T>>, Partial<Result<T>>>;
+    defineComponent<T extends Spec, ConstructorType = Partial<Result<T>>>(spec: T, componentId: number, constructorDefault?: ConstructorType): ComponentDefinition<ISchema<Result<T>>, Partial<Result<T>>>;
     /**
      * Define a component and add it to the engine.
      * @param spec - An object with schema fields
@@ -94,7 +100,7 @@ export declare type IEngine = {
      * const StateComponent = engine.defineComponent(Schemas.Bool, VisibleComponentId)
      * ```
      */
-    defineComponentFromSchema<T extends ISchema<ConstructorType>, ConstructorType>(spec: T, componentId: number, constructorDefault?: ConstructorType): CompDef<T, ConstructorType>;
+    defineComponentFromSchema<T extends ISchema<ConstructorType>, ConstructorType>(spec: T, componentId: number, constructorDefault?: ConstructorType): ComponentDefinition<T, ConstructorType>;
     /**
      * Get the component definition from the component id.
      * @param componentId - component number used to identify the component descriptor
@@ -104,7 +110,7 @@ export declare type IEngine = {
      * const StateComponent = engine.getComponent(StateComponentId)
      * ```
      */
-    getComponent<T extends ISchema>(componentId: number): CompDef<T>;
+    getComponent<T extends ISchema>(componentId: number): ComponentDefinition<T>;
     /**
      * Get the component definition from the component id.
      * @param componentId - component number used to identify the component descriptor
@@ -114,7 +120,7 @@ export declare type IEngine = {
      * const StateComponent = engine.getComponent(StateComponentId)
      * ```
      */
-    getComponentOrNull<T extends ISchema>(componentId: number): CompDef<T> | null;
+    getComponentOrNull<T extends ISchema>(componentId: number): ComponentDefinition<T> | null;
     /**
      * Get a iterator of entities that has all the component requested.
      * @param components - a list of component definitions
@@ -127,11 +133,11 @@ export declare type IEngine = {
      * }
      * ```
      */
-    getEntitiesWith<T extends [CompDef<any>, ...CompDef<any>[]]>(...components: T): Iterable<[Entity, ...ReadonlyComponentSchema<T>]>;
+    getEntitiesWith<T extends [ComponentDefinition<any>, ...ComponentDefinition<any>[]]>(...components: T): Iterable<[Entity, ...ReadonlyComponentSchema<T>]>;
     /**
      * @param deltaTime - deltaTime in seconds
      */
-    update(deltaTime: number): void;
+    update(deltaTime: number): Promise<void>;
     /**
      * @public
      * Refer to the root of the scene, all Transforms without a parent are parenting with RootEntity.

package/dist/serialization/wireMessage.d.ts

@@ -11,6 +11,7 @@
  * available to process the message
  *
  */
+import { ComponentDefinition, Entity, ISchema } from '../engine';
 import { ByteBuffer } from './ByteBuffer';
 export declare namespace WireMessage {
     type Uint32 = number;
@@ -35,5 +36,6 @@ export declare namespace WireMessage {
      */
     function validate(buf: ByteBuffer): boolean;
     function readHeader(buf: ByteBuffer): Header | null;
+    function getType(component: ComponentDefinition<ISchema<unknown>, unknown>, entity: Entity): Enum;
 }
 export default WireMessage;

package/dist/serialization/wireMessage.js

@@ -48,5 +48,9 @@ export var WireMessage;
         };
     }
     WireMessage.readHeader = readHeader;
+    function getType(component, entity) {
+        return component.has(entity) ? Enum.PUT_COMPONENT : Enum.DELETE_COMPONENT;
+    }
+    WireMessage.getType = getType;
 })(WireMessage || (WireMessage = {}));
 export default WireMessage;

package/dist/systems/crdt/index.d.ts

@@ -1,8 +1,10 @@
 import type { IEngine } from '../../engine';
 import { Entity } from '../../engine/entity';
 import { Transport } from './types';
-export declare function crdtSceneSystem(engine: Pick<IEngine, 'getComponentOrNull'>): {
-    createMessages: (dirtyMap: Map<Entity, Set<number>>) => void;
-    receiveMessages: () => void;
+export declare function crdtSceneSystem(engine: Pick<IEngine, 'getComponentOrNull' | 'getComponent' | 'componentsDefinition'>): {
+    getCrdt: () => import("@dcl/crdt").State<Uint8Array>;
+    sendMessages: (dirtyEntities: Map<Entity, Set<number>>) => Promise<void>;
+    receiveMessages: () => Promise<void>;
     addTransport: (transport: Transport) => void;
+    updateState: () => Map<unknown, Set<number>>;
 };

package/dist/systems/crdt/index.js

@@ -9,14 +9,15 @@ export function crdtSceneSystem(engine) {
     // Messages that we received at transport.onMessage waiting to be processed
     const receivedMessages = [];
     // Messages already processed by the engine but that we need to broadcast to other transports.
-    const transportMessages = [];
-    // Map of entities already processed at least once
+    const broadcastMessages = [];
+    // Messages receieved by a transport that were outdated. We need to correct them
+    const outdatedMessages = [];
     /**
      *
-     * @param transportType tranport id to identiy messages
+     * @param transportId tranport id to identiy messages
      * @returns a function to process received messages
      */
-    function parseChunkMessage(transportType) {
+    function parseChunkMessage(transportId) {
         /**
          * Receives a chunk of binary messages and stores all the valid
          * Component Operation Messages at messages queue
@@ -36,7 +37,7 @@ export function crdtSceneSystem(engine) {
                     componentId,
                     data,
                     timestamp,
-                    transportType,
+                    transportId,
                     messageBuffer: buffer
                         .buffer()
                         .subarray(offset, buffer.currentReadOffset())
@@ -50,93 +51,117 @@ export function crdtSceneSystem(engine) {
      * @returns messages recieved by the transport to process on the next tick
      */
     function getMessages(value) {
-        const messagesToProcess = Array.from(value);
-        value.length = 0;
+        const messagesToProcess = value.splice(0, value.length);
         return messagesToProcess;
     }
     /**
      * This fn will be called on every tick.
      * Process all the messages queue received by the transport
      */
-    function receiveMessages() {
+    async function receiveMessages() {
         const messagesToProcess = getMessages(receivedMessages);
-        for (const transport of transports) {
-            const buffer = createByteBuffer();
-            for (const message of messagesToProcess) {
-                const { data, timestamp, componentId, entity, type } = message;
-                const crdtMessage = {
-                    key1: entity,
-                    key2: componentId,
-                    data: data || null,
-                    timestamp: timestamp
-                };
-                const component = engine.getComponentOrNull(componentId);
-                const current = crdtClient.processMessage(crdtMessage);
-                /* istanbul ignore next */
-                if (!component)
-                    // TODO: TEST
-                    continue;
-                // CRDT outdated message. Resend this message through the wire
-                if (crdtMessage !== current) {
-                    const type = component.has(entity)
-                        ? WireMessage.Enum.PUT_COMPONENT
-                        : WireMessage.Enum.DELETE_COMPONENT;
-                    Message.write(type, entity, current.timestamp, component, buffer);
+        const bufferForOutdated = createByteBuffer();
+        for (const message of messagesToProcess) {
+            const { data, timestamp, componentId, entity, type } = message;
+            const crdtMessage = {
+                key1: entity,
+                key2: componentId,
+                data: data || null,
+                timestamp: timestamp
+            };
+            const component = engine.getComponentOrNull(componentId);
+            if (component?.isDirty(entity)) {
+                crdtClient.createEvent(entity, component._id, component.toBinaryOrNull(entity)?.toBinary() || null);
+            }
+            const current = crdtClient.processMessage(crdtMessage);
+            if (!component) {
+                continue;
+            }
+            // CRDT outdated message. Resend this message to the transport
+            // To do this we add this message to a queue that will be processed at the end of the update tick
+            if (crdtMessage !== current) {
+                const offset = bufferForOutdated.currentWriteOffset();
+                const type = WireMessage.getType(component, entity);
+                const ts = current.timestamp;
+                Message.write(type, entity, ts, component, bufferForOutdated);
+                outdatedMessages.push({
+                    ...message,
+                    timestamp: current.timestamp,
+                    messageBuffer: bufferForOutdated
+                        .buffer()
+                        .subarray(offset, bufferForOutdated.currentWriteOffset())
+                });
+            }
+            else {
+                // Add message to transport queue to be processed by others transports
+                broadcastMessages.push(message);
+                // Process CRDT Message
+                if (type === WireMessage.Enum.DELETE_COMPONENT) {
+                    component.deleteFrom(entity, false);
                 }
                 else {
-                    // Process CRDT Message
-                    if (type === WireMessage.Enum.DELETE_COMPONENT) {
-                        component.deleteFrom(entity);
-                    }
-                    else {
-                        const opts = {
-                            reading: { buffer: message.data, currentOffset: 0 }
-                        };
-                        const bb = createByteBuffer(opts);
-                        // Update engine component
-                        component.upsertFromBinary(message.entity, bb);
-                        component.clearDirty();
-                    }
-                    // Add message to transport queue to be processed by others transports
-                    transportMessages.push(message);
+                    const opts = {
+                        reading: { buffer: message.data, currentOffset: 0 }
+                    };
+                    const data = createByteBuffer(opts);
+                    component.upsertFromBinary(message.entity, data, false);
                 }
             }
-            if (buffer.size()) {
-                transport.send(buffer.toBinary());
+        }
+    }
+    function getDirtyMap() {
+        const dirtySet = new Map();
+        for (const [componentId, definition] of engine.componentsDefinition) {
+            for (const entity of definition.dirtyIterator()) {
+                if (!dirtySet.has(entity)) {
+                    dirtySet.set(entity, new Set());
+                }
+                dirtySet.get(entity).add(componentId);
             }
         }
+        return dirtySet;
+    }
+    /**
+     * Updates CRDT state of the current engine dirty components
+     */
+    function updateState() {
+        const dirtyEntities = getDirtyMap();
+        for (const [entity, componentsId] of getDirtyMap()) {
+            for (const componentId of componentsId) {
+                const component = engine.getComponent(componentId);
+                const componentValue = component.toBinaryOrNull(entity)?.toBinary() ?? null;
+                crdtClient.createEvent(entity, componentId, componentValue);
+            }
+        }
+        return dirtyEntities;
     }
     /**
      * Iterates the dirty map and generates crdt messages to be send
-     * @param dirtyMap a map of { entities: [componentId] }
      */
-    function createMessages(dirtyMap) {
+    async function sendMessages(dirtyEntities) {
         // CRDT Messages will be the merge between the recieved transport messages and the new crdt messages
-        const crdtMessages = getMessages(transportMessages);
+        const crdtMessages = getMessages(broadcastMessages);
+        const outdatedMessagesBkp = getMessages(outdatedMessages);
         const buffer = createByteBuffer();
-        for (const [entity, componentsId] of dirtyMap) {
+        for (const [entity, componentsId] of dirtyEntities) {
             for (const componentId of componentsId) {
-                const component = engine.getComponentOrNull(componentId);
-                /* istanbul ignore next */
-                if (!component)
-                    // TODO: test coverage
-                    continue;
-                const entityComponent = component.has(entity)
-                    ? component.toBinary(entity).toBinary()
-                    : null;
-                const event = crdtClient.createEvent(entity, componentId, entityComponent);
+                // Component will be always defined here since dirtyMap its an iterator of engine.componentsDefinition
+                const component = engine.getComponent(componentId);
+                const { timestamp } = crdtClient
+                    .getState()
+                    .get(entity)
+                    .get(componentId);
                 const offset = buffer.currentWriteOffset();
-                const type = component.has(entity)
-                    ? WireMessage.Enum.PUT_COMPONENT
-                    : WireMessage.Enum.DELETE_COMPONENT;
+                const type = WireMessage.getType(component, entity);
                 const transportMessage = {
                     type,
                     componentId,
                     entity,
-                    timestamp: event.timestamp
+                    timestamp
                 };
+                // Avoid creating messages if there is no transport that will handle it
                 if (transports.some((t) => t.filter(transportMessage))) {
-                    Message.write(type, entity, event.timestamp, component, buffer);
+                    Message.write(type, entity, timestamp, component, buffer);
                     crdtMessages.push({
                         ...transportMessage,
                         messageBuffer: buffer
@@ -146,32 +171,55 @@ export function crdtSceneSystem(engine) {
                 }
             }
         }
-        // Send messages to transports
+        // Send CRDT messages to transports
         const transportBuffer = createByteBuffer();
-        for (const transport of transports) {
+        for (const index in transports) {
+            const transportIndex = Number(index);
+            const transport = transports[transportIndex];
             transportBuffer.resetBuffer();
-            for (const message of crdtMessages) {
-                if (transport.filter(message)) {
+            // First we need to send all the messages that were outdated from a transport
+            // So we can fix their crdt state
+            for (const message of outdatedMessagesBkp) {
+                if (message.transportId === transportIndex &&
+                    // Avoid sending multiple messages for the same entity-componentId
+                    !crdtMessages.find((m) => m.entity === message.entity &&
+                        m.componentId === message.componentId)) {
                     transportBuffer.writeBuffer(message.messageBuffer, false);
                 }
             }
-            if (transportBuffer.size()) {
-                transport.send(transportBuffer.toBinary());
-            }
-            else {
-                transport.send(new Uint8Array([]));
+            // Then we send all the new crdtMessages that the transport needs to process
+            for (const message of crdtMessages) {
+                if (message.transportId !== transportIndex &&
+                    transport.filter(message)) {
+                    transportBuffer.writeBuffer(message.messageBuffer, false);
+                }
             }
+            const message = transportBuffer.size()
+                ? transportBuffer.toBinary()
+                : new Uint8Array([]);
+            await transport.send(message);
         }
     }
+    /**
+     * @public
+     * Add a transport to the crdt system
+     */
     function addTransport(transport) {
-        transports.push(transport);
-        transport.onmessage = parseChunkMessage(transport.type);
-        // TODO: pull messages from transport
-        // TODO: send entities to transport
+        const id = transports.push(transport) - 1;
+        transport.onmessage = parseChunkMessage(id);
+    }
+    /**
+     * @public
+     * @returns returns the crdt state
+     */
+    function getCrdt() {
+        return crdtClient.getState();
     }
     return {
-        createMessages,
+        getCrdt,
+        sendMessages,
         receiveMessages,
-        addTransport
+        addTransport,
+        updateState
     };
 }

package/dist/systems/crdt/types.d.ts

@@ -5,14 +5,13 @@ export declare type ReceiveMessage = {
     entity: Entity;
     componentId: number;
     timestamp: number;
-    transportType?: string;
+    transportId?: number;
     data?: Uint8Array;
     messageBuffer: Uint8Array;
 };
 export declare type TransportMessage = Omit<ReceiveMessage, 'data'>;
 export declare type Transport = {
-    type: string;
-    send(message: Uint8Array): void;
+    send(message: Uint8Array): Promise<void>;
     onmessage?(message: Uint8Array): void;
     filter(message: Omit<TransportMessage, 'messageBuffer'>): boolean;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/ecs",
-  "version": "7.0.5",
+  "version": "7.0.6-3652441072.commit-39343cb",
   "description": "Decentraland ECS",
   "main": "./dist/index.js",
   "typings": "./dist/index.d.ts",
@@ -27,7 +27,7 @@
     "ts-proto": "^1.112.0"
   },
   "dependencies": {
-    "@dcl/crdt": "7.0.5",
+    "@dcl/crdt": "7.0.6-3652441072.commit-39343cb",
     "@dcl/js-runtime": "file:../js-runtime",
     "@dcl/protocol": "^1.0.0-3603890942.commit-44633cf"
   },
@@ -35,5 +35,5 @@
     "dist",
     "etc"
   ],
-  "commit": "ad4efbcb7b87a23d25c26ca96f80d3ff795fcd9d"
+  "commit": "39343cb1de3fa2beb4f7cd3955f044216a2be085"
 }