@adobe/data 0.1.2 → 0.2.0

package/src/cache/managed-array.ts

@@ -0,0 +1,243 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { MemoryAllocator } from "./memory-allocator.js";
+import { FromSchema, Schema } from "../schema/index.js";
+import { TypedArray, TypedArrayConstructor } from "../internal/typed-array/index.js";
+import { Data } from "../index.js";
+
+export interface NativeArray<T> {
+  readonly length: number;
+  [n: number]: T;
+}
+
+/**
+ * Represents an abstraction over Arrays, numeric TypedArrays and
+ * TypedArrays which contain tightly packed linear memory structures.
+ */
+export interface ManagedArray<T> {
+  get(index: number): T;
+  set(index: number, value: T): void;
+  readonly native?: NativeArray<T>;
+  readonly constant: boolean;
+
+  ensureCapacity(capacity: number): void;
+  slice(from: number, length: number): Array<T>;
+  move(from: number, to: number): void;
+
+  toJSON(length: number, allowEncoding?: boolean): Data;
+  fromJSON(data: Data, length: number): void;
+}
+
+function createManagedConstantArray<T>(value: T): ManagedArray<T> {
+  return {
+    constant: true,
+    get(_index: number): T {
+      return value;
+    },
+    set(_index: number, _value: T): void { },
+    move(_from: number, _to: number): void { },
+    slice(_from: number, _length: number): Array<T> {
+      return [value];
+    },
+    ensureCapacity(_capacity: number) { },
+    toJSON(_length: number) {
+      return value as Data;
+    },
+    fromJSON(data: Data) {
+      if (data !== value) {
+        throw new Error(`Cannot set constant array to ${data}`);
+      }
+    },
+  };
+}
+
+function createManagedBasicArray<T>(): ManagedArray<T> {
+  const array: T[] = [];
+  return {
+    constant: false,
+    native: array,
+    get: (index: number) => array[index],
+    set: (index: number, value: T) => (array[index] = value),
+    move: (from: number, to: number) => (array[to] = array[from]),
+    ensureCapacity: (_capacity: number) => { },
+    slice: (from: number, length: number) => array.slice(from, from + length),
+    toJSON(length: number) {
+      return array.slice(0, length) as Data;
+    },
+    fromJSON(data: Data) {
+      if (!Array.isArray(data)) {
+        throw new Error(`Cannot set array to ${data}`);
+      }
+      array.length = 0;
+      array.push(...data as T[]);
+    },
+  };
+}
+
+function binaryEncode(subarray: TypedArray): string {
+  return btoa(
+    String.fromCharCode(
+      ...new Uint8Array(
+        subarray.buffer,
+        subarray.byteOffset,
+        subarray.byteLength
+      )
+    )
+  );
+}
+
+function binaryDecode(
+  data: string,
+  length: number,
+  ctor: TypedArrayConstructor
+): TypedArray {
+  const binaryString = atob(data);
+  const byteArray = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    byteArray[i] = binaryString.charCodeAt(i);
+  }
+  return new ctor(byteArray.buffer, byteArray.byteOffset, length);
+}
+
+function createManagedTypedArray(
+  ctor: TypedArrayConstructor,
+  allocator: MemoryAllocator
+): ManagedArray<number> {
+  let capacity = 16;
+  let array = allocator.allocate(ctor, capacity);
+  //  when the main wasm memory is resized, we need to refresh the array.
+  allocator.needsRefresh(() => {
+    array = allocator.refresh(array);
+  });
+
+  const grow = (newCapacity?: number) => {
+    if (newCapacity && newCapacity > capacity) {
+      array = allocator.refresh(array);
+      const oldArray = array;
+      const growthFactor = 2;
+      capacity = Math.max(newCapacity, capacity * growthFactor);
+      const newArray = allocator.allocate(ctor, capacity);
+      newArray.set(array);
+      array = newArray;
+      allocator.release(oldArray);
+    }
+  };
+  const result = {
+    constant: false,
+    get native() {
+      return array;
+    },
+    get(index: number) {
+      return array[index];
+    },
+    set(index: number, value: number): void {
+      // if (index >= capacity) {
+      //   grow();
+      // }
+      array[index] = value;
+    },
+    move(from: number, to: number): void {
+      array[to] = array[from];
+    },
+    slice(start: number, end: number) {
+      return [...array.subarray(start, end)];
+    },
+    ensureCapacity(newCapacity: number) {
+      grow(newCapacity);
+    },
+    toJSON(length: number, allowEncoding = true) {
+      const subarray = array.subarray(0, length);
+      if (!allowEncoding) {
+        return Array.from(subarray);
+      }
+      const jsonString = JSON.stringify(Array.from(subarray));
+      const binaryString = binaryEncode(subarray);
+      return binaryString.length < jsonString.length
+        ? binaryString
+        : Array.from(subarray);
+    },
+    fromJSON(data: Data, length: number) {
+      if (typeof data === "string") {
+        const decodedArray = binaryDecode(data, length, ctor);
+        if (decodedArray.length > capacity) {
+          grow(decodedArray.length);
+        }
+        array.set(decodedArray);
+      } else {
+        if (!Array.isArray(data)) {
+          throw new Error(`Cannot set array to ${data}`);
+        }
+        if (data.length > capacity) {
+          grow(data.length);
+        }
+        array.set(data as number[]);
+      }
+    },
+  };
+  return result;
+}
+
+export function createManagedArray<S extends Schema>(
+  s: S,
+  allocator: MemoryAllocator
+): ManagedArray<FromSchema<S>> {
+  if (s.const !== undefined) {
+    return createManagedConstantArray(s.const) as ManagedArray<FromSchema<S>>;
+  }
+  if (s.type === "number") {
+    if (s.precision === 1) {
+      return createManagedTypedArray(Float32Array, allocator) as ManagedArray<
+        FromSchema<S>
+      >;
+    }
+    // default to double precision float
+    return createManagedTypedArray(Float64Array, allocator) as ManagedArray<
+      FromSchema<S>
+    >;
+  }
+  if (
+    s.type === "integer" &&
+    s.minimum !== undefined
+  ) {
+    if (s.minimum >= 0) {
+      if (s.maximum) {
+        // unsigned integers
+        if (s.maximum <= 0xff) {
+          return createManagedTypedArray(Uint8Array, allocator) as ManagedArray<
+            FromSchema<S>
+          >;
+        }
+        if (s.maximum <= 0xffff) {
+          return createManagedTypedArray(Uint16Array, allocator) as ManagedArray<
+            FromSchema<S>
+          >;
+        }
+        if (s.maximum <= 0xffffffff) {
+          return createManagedTypedArray(Uint32Array, allocator) as ManagedArray<
+            FromSchema<S>
+          >;
+        }
+      }
+    }
+  }
+  return createManagedBasicArray();
+}

package/{cache/managed-async-cache.browser.test.js → src/cache/managed-async-cache.browser.test.ts}

@@ -22,29 +22,32 @@ SOFTWARE.*/
 import { createManagedAsyncCache } from "./managed-async-cache.js";
 import { createMemoryAsyncCache } from "./memory-async-cache.js";
 import { describe, expect, it } from "vitest";
+
 describe("ManagedAsyncCache", () => {
-    it("should retain new data but evict old data", async () => {
-        const optimum = 4;
-        const maximumEntries = optimum * 2;
-        const cache = createManagedAsyncCache(createMemoryAsyncCache(), optimum);
-        const count = 100;
-        for (let i = 0; i < count; i++) {
-            await cache.put(new Request(`key:${i}`), new Response(`value:${i}`));
-        }
-        // make sure we don't exceed maximum keys
-        const keyCount = await cache.getKeyCountForTesting();
-        //  should not store more than maximum keys
-        expect(keyCount <= maximumEntries).toBe(true);
-        // make the last N requests still available.
-        for (let k = 0; k < optimum; k++) {
-            const i = count - 1 - k;
-            const value = await cache.match(new Request(`key:${i}`));
-            expect(value instanceof Response).toBe(true);
-        }
-        //  old keys should return undefined
-        expect(await cache.match(new Request(`key:0`))).toBe(undefined);
-        expect(await cache.match(new Request(`key:1`))).toBe(undefined);
-        expect(await cache.match(new Request(`key:2`))).toBe(undefined);
-    });
+  it("should retain new data but evict old data", async () => {
+    const optimum = 4;
+    const maximumEntries = optimum * 2;
+    const cache = createManagedAsyncCache(createMemoryAsyncCache(), optimum);
+    const count = 100;
+    for (let i = 0; i < count; i++) {
+      await cache.put(new Request(`key:${i}`), new Response(`value:${i}`));
+    }
+
+    // make sure we don't exceed maximum keys
+    const keyCount = await cache.getKeyCountForTesting();
+    //  should not store more than maximum keys
+    expect(keyCount <= maximumEntries).toBe(true);
+
+    // make the last N requests still available.
+    for (let k = 0; k < optimum; k++) {
+      const i = count - 1 - k;
+      const value = await cache.match(new Request(`key:${i}`));
+      expect(value instanceof Response).toBe(true);
+    }
+
+    //  old keys should return undefined
+    expect(await cache.match(new Request(`key:0`))).toBe(undefined);
+    expect(await cache.match(new Request(`key:1`))).toBe(undefined);
+    expect(await cache.match(new Request(`key:2`))).toBe(undefined);
+  });
 });
-//# sourceMappingURL=managed-async-cache.browser.test.js.map

package/src/cache/managed-async-cache.ts

@@ -0,0 +1,78 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import type { AsyncCache, AsyncCacheWithKeys } from "./async-cache.js";
+
+const CREATED_HEADER = "ManagedAsyncCache.Created";
+
+export function createManagedAsyncCache(
+  cache: AsyncCacheWithKeys<Request, Response>,
+  optimumEntries: number
+): AsyncCache<Request, Response> & {
+  getKeyCountForTesting(): Promise<number>;
+} {
+  const maximumEntries = optimumEntries * 2;
+  let putCount = 0;
+
+  const maybeManageCacheOnPut = async () => {
+    if (putCount++ % optimumEntries === 0) {
+      let keys = [...(await cache.keys())];
+      if (keys.length >= maximumEntries) {
+        // sort by created. ISO date strings are comparable by date
+        keys = keys.sort((a, b) => {
+          const aheader = a.headers.get(CREATED_HEADER);
+          const bheader = b.headers.get(CREATED_HEADER);
+          if (!aheader || !bheader) {
+            return 0;
+          }
+          return aheader.localeCompare(bheader);
+        });
+        while (keys.length > optimumEntries) {
+          const key = keys.shift();
+          if (key) {
+            await cache.delete(key);
+          }
+        }
+      }
+    }
+  };
+
+  return {
+    async put(key: Request, value: Response): Promise<void> {
+      // add a created header as metadata to the request
+      key.headers.set(CREATED_HEADER, new Date().toISOString());
+      await cache.put(key, value);
+      await maybeManageCacheOnPut();
+    },
+
+    async match(key: Request): Promise<Response | undefined> {
+      return cache.match(key);
+    },
+
+    async delete(key: Request): Promise<void> {
+      await cache.delete(key);
+    },
+
+    async getKeyCountForTesting(): Promise<number> {
+      return (await cache.keys()).length;
+    },
+  };
+}

package/src/cache/memory-allocator.ts

@@ -0,0 +1,176 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { TypedArray, TypedArrayConstructor } from "../internal/typed-array/index.js";
+import { createObservableEvent } from "../observe/create-observable-event.js";
+import { Observe } from "../observe/types.js";
+
+export interface MemoryAllocator {
+  /**
+   * An observable event source that notifies when the memory needs to be refreshed.
+   */
+  needsRefresh: Observe<void>;
+  /**
+   * Allocate a new typed array of the specified size.
+   */
+  allocate<T extends TypedArrayConstructor>(
+    typedArray: T,
+    sizeInElements: number
+  ): InstanceType<T>;
+  /**
+   * Refresh the given typed array to ensure that it is not detached.
+   * If it is detached a new typed array is created and returned.
+   */
+  refresh<T extends TypedArrayConstructor>(
+    typedArray: InstanceType<T>
+  ): InstanceType<T>;
+  /**
+   * Release the memory associated with the given buffer.
+   */
+  release(buffer: TypedArray): void;
+}
+
+export function createSimpleMemoryAllocator(): MemoryAllocator {
+  return {
+    needsRefresh: () => () => { },
+    allocate<T extends TypedArrayConstructor>(
+      typedArray: T,
+      sizeInElements: number
+    ): InstanceType<T> {
+      const sizeInBytes = sizeInElements * typedArray.BYTES_PER_ELEMENT;
+      return new typedArray(
+        new ArrayBuffer(sizeInBytes),
+        0,
+        sizeInElements
+      ) as InstanceType<T>;
+    },
+    refresh<T extends TypedArrayConstructor>(typedArray: InstanceType<T>) {
+      return typedArray;
+    },
+    release(_buffer: TypedArray): void {
+      return;
+    },
+  };
+}
+
+const PAGE_SIZE = 64 * 1024; // 64 KB
+
+export function createWasmMemoryAllocator(
+  memory: WebAssembly.Memory
+): MemoryAllocator {
+  const freeList = [{ offset: 0, size: memory.buffer.byteLength }];
+
+  const [needsRefresh, notifyNeedsRefresh] = createObservableEvent<void>();
+
+  const mergeFreeBlocks = (): void => {
+    // Sort the free list by offset
+    freeList.sort((a, b) => a.offset - b.offset);
+
+    let i = 0;
+    while (i < freeList.length - 1) {
+      const current = freeList[i];
+      const next = freeList[i + 1];
+      // Check if current block is adjacent to the next
+      if (current.offset + current.size === next.offset) {
+        // Merge the blocks
+        current.size += next.size;
+        // Remove the next block
+        freeList.splice(i + 1, 1);
+      } else {
+        i++;
+      }
+    }
+  };
+
+  const growMemory = (sizeInBytes: number): number => {
+    const currentSize = memory.buffer.byteLength;
+    const neededPages = Math.ceil(sizeInBytes / PAGE_SIZE); // Each WebAssembly page is 65536 bytes
+    memory.grow(neededPages);
+    freeList.push({
+      offset: currentSize,
+      size: memory.buffer.byteLength - currentSize,
+    });
+    mergeFreeBlocks();
+    notifyNeedsRefresh();
+    return freeList.length - 1;
+  };
+
+  const allocate = <T extends TypedArrayConstructor>(
+    typedArray: TypedArrayConstructor,
+    sizeInElements: number
+  ): InstanceType<T> => {
+    const ALIGNMENT = 16;
+    const sizeInBytes =
+      Math.ceil((sizeInElements * typedArray.BYTES_PER_ELEMENT) / ALIGNMENT) *
+      ALIGNMENT;
+    let index = freeList.findIndex((block) => block.size >= sizeInBytes);
+    if (index === -1) {
+      index = growMemory(sizeInBytes);
+    }
+
+    const block = freeList[index];
+    freeList.splice(index, 1); // Remove the block from the free list
+    const remainingSize = block.size - sizeInBytes;
+    if (remainingSize > 0) {
+      freeList.push({
+        offset: block.offset + sizeInBytes,
+        size: remainingSize,
+      });
+    }
+
+    return new typedArray(
+      memory.buffer,
+      block.offset,
+      sizeInElements
+    ) as InstanceType<T>;
+  };
+
+  const refresh = <T extends TypedArrayConstructor>(
+    array: InstanceType<T>
+  ): InstanceType<T> => {
+    if (memory.buffer.byteLength !== array.byteLength) {
+      return new (array.constructor as any)(
+        memory.buffer,
+        array.byteOffset,
+        array.length
+      );
+    }
+    return array;
+  };
+
+  const release = (memory: TypedArray): void => {
+    if (memory.byteOffset !== undefined) {
+      const newFreeBlock = {
+        offset: memory.byteOffset,
+        size: memory.byteLength,
+      };
+      freeList.push(newFreeBlock);
+      mergeFreeBlocks();
+    }
+  };
+
+  return {
+    needsRefresh,
+    allocate,
+    refresh,
+    release,
+  };
+}

package/src/cache/memory-async-cache.ts

@@ -0,0 +1,51 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import type { AsyncCacheWithKeys } from "./async-cache.js";
+
+/**
+ * This should never be used directly as it will never free cache entries making it leak memory.
+ * It should only ever be used as a base cache inside of a ManagedAsyncCache.
+ */
+export function createMemoryAsyncCache(): AsyncCacheWithKeys<
+  Request,
+  Response
+> {
+  const cache = new Map<string, [Request, Response]>();
+  return {
+    put(key: Request, value: Response): Promise<void> {
+      cache.set(key.url, [key, value.clone()]);
+      return Promise.resolve();
+    },
+
+    match(key: Request): Promise<Response | undefined> {
+      return Promise.resolve(cache.get(key.url)?.[1]?.clone());
+    },
+
+    async delete(key: Request): Promise<void> {
+      await Promise.resolve(cache.delete(key.url));
+    },
+
+    keys(): Promise<ReadonlyArray<Request>> {
+      return Promise.resolve([...cache.values()].map((value) => value[0]));
+    },
+  };
+}

package/src/data.ts

@@ -0,0 +1,38 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+
+/**
+ * Data is readonly JSON.
+ * This type forms the foundation for all of our internal state models and interfaces to external APIs.
+ * It is easy to serialize/deserialize/compare/hash/cache and validate (with JSON-Schema).
+ * These traits make it an ideal foundation for building a robust state engine which cannot enter into invalid states.
+ * It also allows us to strongly define contracts between our application and external services.
+ * Validation of input arguments and output results allows strict enforcement of agreed upon contracts.
+ */
+export type Data =
+  | string
+  | number
+  | boolean
+  | null
+  | undefined
+  | ReadonlyArray<Data>
+  | { readonly [K in string]?: Data };

package/src/ecs/README.md

@@ -0,0 +1,21 @@
+## New ECS Folder
+
+### New Features Needed
+
+ECS Core Database
+- [x] components can have null value, deleting components is distinct from setting to null.
+- [x] simplify and improve type definitions.
+- [x] allow to define new components with separate schema and type declarations.
+- [x] fix deserialization with constant columns.
+
+ECS Transactional Database
+- [x] .components
+- [x] .resources
+- [x] .archetypes
+- [ ] selectEntityValues with optional filter
+- [x] observations and transactions on updates
+
+ECS Action Database
+- [-] applied actions are stored directly within the database.
+- [x] logic to prune old applied actions after a certain point.
+- [x] action sequences