@adobe/ecs 0.1.0 → 0.2.1

package/src/interface/math/vec4/u32/negate.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { U32 as Vec4_U32 } from "./u32.js";
 
 export const negate = ([x, y, z, w]: Vec4_U32): Vec4_U32 => [(-x) >>> 0, (-y) >>> 0, (-z) >>> 0, (-w) >>> 0];

package/src/interface/math/vec4/u32/one.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { U32 as Vec4_U32 } from "./u32.js";
 
 export const one: Vec4_U32 = [1, 1, 1, 1];

package/src/interface/math/vec4/u32/public.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 export * from "./add.js";
 export * from "./bitwise-and.js";
 export * from "./bitwise-not.js";
@@ -20,3 +21,4 @@ export * from "./shift-right.js";
 export * from "./subtract.js";
 export * from "./zero.js";
 export * from "./schema.js";
+export { zero as default } from "./zero.js";

package/src/interface/math/vec4/u32/reverse-bits.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { U32 as Vec4_U32 } from "./u32.js";
 import { U32 } from "../../u32/index.js";
 import { intrinsic } from "../../intrinsic.js";

package/src/interface/math/vec4/u32/scale.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { U32 as Vec4_U32 } from "./u32.js";
 import { intrinsic } from "../../intrinsic.js";
 import type { U32 } from "../../u32/index.js";

package/src/interface/math/vec4/u32/schema.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Schema } from "../../../schema/schema.js";
 import { schema as item } from "../../u32/schema.js";
 

package/src/interface/math/vec4/u32/shift-left.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { U32 as Vec4_U32 } from "./u32.js";
 
 export const shiftLeft = ([x, y, z, w]: Vec4_U32, s: number): Vec4_U32 => [

package/src/interface/math/vec4/u32/shift-right.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { U32 as Vec4_U32 } from "./u32.js";
 import { U32 } from "../../u32/index.js";
 

package/src/interface/math/vec4/u32/subtract.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { U32 as Vec4_U32 } from "./u32.js";
 import { intrinsic } from "../../intrinsic.js";
 

package/src/interface/math/vec4/u32/u32.ts

@@ -1,4 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Schema } from "../../../schema/schema.js";
+import type { schema } from "./schema.js";
+
 /** Vectors of integers in [0, 2^32). Functions wrap as WGSL's u32 does; for other values their results are indeterminate. */
-export type U32 = readonly [number, number, number, number];
+export type U32 = Schema.Type<typeof schema>;
 
 export * as U32 from "./public.js";

package/src/interface/math/vec4/u32/zero.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { U32 as Vec4_U32 } from "./u32.js";
 
 export const zero: Vec4_U32 = [0, 0, 0, 0];

package/src/interface/platform/platform.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /**
  * The instance type of the global constructor `Name`, or `never` where the loaded libraries don't declare it, so types
  * that name platform classes compile with or without the DOM and worker libraries.

package/src/interface/registry/archetypes.test.ts

@@ -0,0 +1,50 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, expect, it } from "vitest";
+import { archetypeIndexKey, indexArchetype } from "./archetypes.js";
+
+/** The index a list was given, or -1 without one. */
+const archetypeIndexOf = (list: readonly unknown[]): number => {
+    const index: unknown = Reflect.get(list, archetypeIndexKey);
+    return typeof index === "number" ? index : -1;
+};
+
+const position = Symbol();
+const velocity = Symbol();
+const gravity = Symbol();
+declare module "@adobe/ecs" {
+    interface Components {
+        [position]: { type: number };
+        [velocity]: { type: number };
+    }
+    interface Resources {
+        [gravity]: { type: number };
+    }
+}
+
+/** Lists the build gives indexes: top-level lists of components declared as const. */
+const Particle = [position, velocity] as const;
+const Moving = [velocity] as const;
+/** A list naming a resource takes an index too: where it's used, it's found not to be a list of components. */
+const WithResource = [position, gravity] as const;
+
+describe("archetype indexes", () => {
+    it("are given by the build to each top-level list of components declared as const", () => {
+        expect(archetypeIndexOf(Particle)).toBeGreaterThanOrEqual(0);
+        expect(archetypeIndexOf(Moving)).toBeGreaterThanOrEqual(0);
+        expect(archetypeIndexOf(Moving)).not.toBe(archetypeIndexOf(Particle));
+        expect(Object.keys(Particle)).toEqual(["0", "1"]);
+    });
+    it("aren't given to a list made at runtime, and are to one of symbols whatever they key", () => {
+        expect(archetypeIndexOf([position, velocity])).toBe(-1);
+        expect(archetypeIndexOf(WithResource)).toBeGreaterThanOrEqual(0);
+    });
+    it("are given to the package's own lists once, and never twice", () => {
+        const list = [position];
+        indexArchetype(list);
+        const index = archetypeIndexOf(list);
+        indexArchetype(list);
+        expect(index).toBeGreaterThanOrEqual(0);
+        expect(archetypeIndexOf(list)).toBe(index);
+        expect(() => indexArchetype([position, velocity, position])).toThrow("twice");
+    });
+});

package/src/interface/registry/archetypes.ts

@@ -1,23 +1,59 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { labelOf } from './names.js';
 
-/** Where an archetype holds its program-wide index: a property no other code names. */
-const indexKey = Symbol("archetypeIndex");
+/**
+ * The `Symbol.for` names of the property holding a list's program-wide archetype index, and of the global count of
+ * indexes given, which code the plugin generates and every copy of the package share. Their version changes with the
+ * format.
+ */
+export const archetypeIndexName = "@adobe/ecs/archetype@1";
+export const archetypeCountName = "@adobe/ecs/archetypes@1";
 
-let next = 0;
+/**
+ * The property a list holds its index in: a number for a list the plugin or the package indexed, which never changes;
+ * the world's record of a list made at runtime, which it checks against the list's keys (`world/lists.ts`).
+ */
+export const archetypeIndexKey: symbol = Symbol.for(archetypeIndexName);
+const indexKey = archetypeIndexKey;
+const countKey = Symbol.for(archetypeCountName);
 
 /**
  * Gives a list of components a program-wide index, once, after checking it names no component twice. Throws for a
- * component listed twice.
+ * component listed twice. The package's own lists take it here; the plugin gives consumers' theirs.
  */
 export const indexArchetype = (components: readonly unknown[]): void => {
     for (let k = 1; k < components.length; k++) {
         if (components.indexOf(components[k]) < k) throw new Error(`An archetype lists "${labelOf(components[k])}" twice.`);
     }
-    if (!Reflect.has(components, indexKey)) Object.defineProperty(components, indexKey, { value: next++ });
+    if (typeof Reflect.get(components, indexKey) !== "number") Object.defineProperty(components, indexKey, { value: nextArchetypeIndex() });
+};
+
+/** The next program-wide archetype index, from the count every copy of the package and generated code share. */
+export const nextArchetypeIndex = (): number => {
+    const count: unknown = Reflect.get(globalThis, countKey);
+    const next = typeof count === "number" ? count : 0;
+    Reflect.set(globalThis, countKey, next + 1);
+    return next;
 };
 
-/** The program-wide index `Archetype.create` gave a list, or -1 for a list it wasn't given. */
-export const archetypeIndexOf = (components: readonly unknown[]): number => {
-    const index: unknown = Reflect.get(components, indexKey);
-    return typeof index === "number" ? index : -1;
+/** The keys of a list made at runtime, in its order, and the one program-wide index every list of them shares. */
+export type Interned = { readonly keys: readonly unknown[]; readonly index: number };
+
+type Node = { interned: Interned | null; readonly next: Map<unknown, Node> };
+
+const root: Node = { interned: null, next: new Map() };
+
+/**
+ * The index lists made at runtime of `list`'s keys, in its order, share: given the first time, then found without
+ * allocating, so lists made on every call take one index between them.
+ */
+export const internArchetype = (list: readonly unknown[]): Interned => {
+    let node = root;
+    for (let k = 0; k < list.length; k++) {
+        const key = list[k];
+        let next = node.next.get(key);
+        if (next === undefined) node.next.set(key, next = { interned: null, next: new Map() });
+        node = next;
+    }
+    return node.interned ??= { keys: [...list], index: nextArchetypeIndex() };
 };

package/src/interface/registry/declarations.ts

@@ -1,17 +1,19 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Schema } from '../schema/schema.js';
 import type { Key as TraitKey } from '../trait/key.js';
+import { declarationsName } from './ids.js';
 import { layoutOf } from './layout.js';
-import { claimKey, declarationOf, failRegistration, firstKeyOf, kindOf, labelOf, requireKey, sameDeclaration } from './names.js';
+import { claimKey, declarationOf, failRegistration, firstKeyOf, installCatchUp, kindOf, labelOf, recordFailure, requireKey, sameDeclaration } from './names.js';
 import { isReduction } from './reduction.js';
-import { allowsNull, hasBoolean, isEntity, isString, isStruct } from './schemas.js';
-import { isTrait } from './traits.js';
+import { allowsNull, hasBoolean, isComparable, isEntity, isString, isStruct, matchesSchema } from './schemas.js';
+import { addTrait, isTrait } from './traits.js';
 
 /**
  * A registered declaration, as any consumer iterating components or resources sees it: its `type` and other traits.
- * Without `type`, the value isn't data. A resource's `default`, or a derived object's, is what it starts at, when its
- * schema has none.
+ * Without `type`, the value isn't data. `default` is what it starts at, never its schema's, which holds none; `fresh`
+ * starts it as an empty `Map` or `Set` of each world's own.
  */
-export type AnyDeclaration = { readonly type?: Schema; readonly default?: unknown } & { readonly [T in TraitKey]?: unknown };
+export type AnyDeclaration = { readonly type?: Schema; readonly default?: unknown; readonly fresh?: unknown } & { readonly [T in TraitKey]?: unknown };
 
 /** The value schema of any registered component or resource, or undefined for a value that isn't data. */
 export const schemaOf = (key: unknown): Schema | undefined => declarationOf(key)?.type;
@@ -34,19 +36,40 @@ const isInstance = (value: unknown, name: string): boolean => {
  */
 export const threadOfDeclaration = (declaration: AnyDeclaration): string | null => {
     if (declaration.type !== undefined && (isStruct(declaration.type) || isString(declaration.type))) return null;
+    // A shared component's value is its archetype's, which every thread reads.
+    if (declaration.shared === true) return null;
     return typeof declaration.thread === "string" ? declaration.thread : "world";
 };
 
+/** Whether a schema, or any schema inside it, holds a `default`. */
+const holdsDefault = (schema: Schema): boolean => {
+    if ("default" in schema) return true;
+    if ("anyOf" in schema) return schema.anyOf.some(holdsDefault);
+    if ("allOf" in schema) return schema.allOf.some(holdsDefault);
+    if ("const" in schema) return false;
+    switch (schema.type) {
+        case "object": return Object.values(schema.properties).some(holdsDefault);
+        case "array": case "set": return holdsDefault(schema.items);
+        case "map": return holdsDefault(schema.keys) || holdsDefault(schema.values);
+        default: return false;
+    }
+};
+
 /** Throws for a declaration whose traits can't hold, so far as values tell: types check the rest. */
 const check = (kind: "component" | "resource", key: symbol, declaration: AnyDeclaration): void => {
     const fail = (message: string): never => failRegistration(kind, key, message);
     for (const trait of Reflect.ownKeys(declaration)) {
-        if (trait !== "default" && !isTrait(trait)) fail(`${labelOf(trait)} isn't a registered trait.`);
+        if (trait !== "default" && trait !== "fresh" && !isTrait(trait)) fail(`${labelOf(trait)} isn't a registered trait.`);
     }
-    const { type } = declaration;
-    if (type !== undefined && "default" in declaration && (kind === "component" || "default" in type)) {
-        fail(kind === "component" ? "its schema holds its default." : "its default is given twice, by its schema and its declaration.");
+    const { type, fresh } = declaration;
+    if (type !== undefined && holdsDefault(type)) fail("its schema holds a default, which a schema never does: its start is its declaration's default.");
+    if (fresh !== undefined) {
+        if (fresh !== "Map" && fresh !== "Set") fail(`fresh is "Map" or "Set".`);
+        if ("default" in declaration) fail("it starts fresh, so it has no default.");
+        if (type !== undefined && "type" in type && (type.type === "set" || type.type === "map") && (type.type === "set") !== (fresh === "Set")) fail(`a ${type.type} starts as a fresh ${type.type === "set" ? "Set" : "Map"}.`);
     }
+    // A start however the build found it, a literal, its type's namespace's or an identity, is one of its type's values.
+    if (type !== undefined && "default" in declaration && !matchesSchema(type, declaration.default)) fail(`its default, ${labelOf(declaration.default)}, isn't one of its type's values.`);
     try {
         layoutOf(type);
     }
@@ -63,8 +86,10 @@ const check = (kind: "component" | "resource", key: symbol, declaration: AnyDecl
         cycle.push(first);
     }
     if (declaration.derived !== undefined && kind !== "component") fail("only a component is derived.");
-    if (declaration.derived === true && type !== undefined && !("default" in type || "const" in type || allowsNull(type))) {
-        fail("a derived component's type has a default, which it starts at.");
+    if (declaration.derived === true && declaration.within !== undefined) fail("a derived component's rule covers within.");
+    if (declaration.derived === true && declaration.reference !== undefined) fail("a rule can't set a derived component's target, so it's no reference.");
+    if (declaration.derived === true && type !== undefined && fresh === undefined && !("default" in declaration || "const" in type || allowsNull(type))) {
+        fail("a derived component has a default, which it starts at.");
     }
     if (declaration.reduce !== undefined) {
         const operator = declaration.reduce;
@@ -80,6 +105,15 @@ const check = (kind: "component" | "resource", key: symbol, declaration: AnyDecl
         if (type !== undefined && isString(type)) fail("a string lives in shared memory, so it has no thread.");
     }
     if (isInstance(declaration.default, "Node") && thread !== "main") fail(`a DOM Node lives on "main".`);
+    const { shared } = declaration;
+    if (shared !== undefined) {
+        if (shared !== true) fail("shared is true.");
+        if (kind !== "component") fail("only a component is shared.");
+        if (type === undefined || !isComparable(type)) fail("a shared component's value is comparable data: numbers, booleans, strings, and arrays and objects of those.");
+        if (thread !== undefined) fail("a shared value lives in shared memory, so it has no thread.");
+        if (declaration.derived !== undefined) fail("a derived component isn't shared: its rule adds it with its default.");
+        if (declaration.reference !== undefined) fail("a reference isn't shared: its target despawning acts on each holder.");
+    }
     const { transfer } = declaration;
     if (transfer !== undefined) {
         if (transfer !== true) fail("transfer is true.");
@@ -93,10 +127,70 @@ const check = (kind: "component" | "resource", key: symbol, declaration: AnyDecl
  * Registers a declaration of `kind` under `key`, fixed from then on. The same declaration again is accepted, and so is
  * a new symbol with the id of a key of this kind, as a module evaluated again makes it.
  */
-export const createRegistry = (kind: "component" | "resource") => (key: unknown, declaration: AnyDeclaration): void => {
+const createRegistry = (kind: "component" | "resource") => (key: unknown, declaration: AnyDeclaration): void => {
     const symbol = requireKey(kind, key);
     const existing = kindOf(symbol);
     if (existing === kind && sameDeclaration(declarationOf(symbol), declaration)) return;
     if (existing === undefined) check(kind, symbol, declaration);
     claimKey(symbol, kind, declaration);
 };
+
+/** Registers a component: the package's own, and tests' keys made at runtime; the build declares every other. */
+export const registerComponent = createRegistry("component");
+
+/** Registers a resource: the package's own, and tests' keys made at runtime; the build declares every other. */
+export const registerResource = createRegistry("resource");
+
+/** The global map of what the build declared, made here when no generated code made it first. */
+const declared = ((): Map<unknown, unknown> => {
+    const name = Symbol.for(declarationsName);
+    const found: unknown = Reflect.get(globalThis, name);
+    if (found instanceof Map) return found;
+    const made = new Map<unknown, unknown>();
+    Reflect.set(globalThis, name, made);
+    return made;
+})();
+
+/** Whether a value the generated code recorded is a declaration: an object of traits, as the build wrote it. */
+const isDeclaration = (value: unknown): value is AnyDeclaration => typeof value === "object" && value !== null;
+
+/** Registers one key the build declared, as its kind says. */
+const registerDeclared = (key: unknown, entry: unknown): void => {
+    const kind: unknown = typeof entry === "object" && entry !== null ? Reflect.get(entry, "kind") : undefined;
+    const declaration: unknown = typeof entry === "object" && entry !== null ? Reflect.get(entry, "declaration") : undefined;
+    if (kind === "trait") addTrait(key);
+    else if (kind === "component" && isDeclaration(declaration)) registerComponent(key, declaration);
+    else if (kind === "resource" && isDeclaration(declaration)) registerResource(key, declaration);
+};
+
+/** How many of the map's entries this copy registered. */
+let seen = 0;
+let catching = false;
+
+/**
+ * Registers what the build declared since this last ran, in the order modules evaluated, as each module registered
+ * its keys when it was evaluated. A declaration that fails is recorded for its own key, whose every use fails giving
+ * it as the reason, and never for a read of another key. Reads of keys while it runs see those registered so far.
+ */
+const catchUp = (): void => {
+    if (catching || declared.size === seen) return;
+    catching = true;
+    try {
+        let index = 0;
+        for (const [key, entry] of declared) {
+            if (index++ < seen) continue;
+            seen++;
+            try {
+                registerDeclared(key, entry);
+            }
+            catch (error) {
+                if (typeof key === "symbol") recordFailure(key, error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+    finally {
+        catching = false;
+    }
+};
+
+installCatchUp(catchUp);

package/src/interface/registry/declared.test.ts

@@ -0,0 +1,40 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, expect, it } from "vitest";
+import { identify, recordDeclaration } from "./ids.test-helper.js";
+import "./declarations.js";
+import { declarationOf, kindOf, sameKey, whyUnregistered } from "./names.js";
+
+describe("declarations the build records", () => {
+    it("registers a key at its first use, as its kind says", () => {
+        const speed = Symbol("declaredTest/speed");
+        const tag = Symbol("declaredTest/tag");
+        recordDeclaration(speed, "resource", { type: { type: "number" }, default: 1 });
+        recordDeclaration(tag, "trait");
+        expect([kindOf(speed), kindOf(tag)]).toEqual(["resource", "trait"]);
+        expect(declarationOf(speed)).toEqual({ type: { type: "number" }, default: 1 });
+    });
+    it("registers in the order modules recorded them, so a trait comes before what declares it", () => {
+        const mark = Symbol("declaredTest/mark");
+        const marked = Symbol("declaredTest/marked");
+        recordDeclaration(mark, "trait");
+        recordDeclaration(marked, "component", { type: { const: true }, [mark]: true });
+        expect(kindOf(marked)).toBe("component");
+    });
+    it("takes another symbol of one id, as a module evaluated again records it, as the same key", () => {
+        const first = identify(Symbol("declaredTest/again"), "declaredTest/keys.ts#again");
+        const again = identify(Symbol("declaredTest/again"), "declaredTest/keys.ts#again");
+        recordDeclaration(first, "component", { type: { type: "number" } });
+        recordDeclaration(again, "component", { type: { type: "number" } });
+        expect([kindOf(again), sameKey(first, again)]).toEqual(["component", true]);
+    });
+    it("never throws a declaration that fails for another key's use, and gives it as the reason its own key's uses fail", () => {
+        const late = Symbol("declaredTest/late");
+        const fine = Symbol("declaredTest/fine");
+        recordDeclaration(late, "component", { type: { type: "number" }, reduce: "+" });
+        recordDeclaration(fine, "component", { type: { type: "number" } });
+        expect([kindOf(fine), kindOf(late)]).toEqual(["component", undefined]);
+        expect(whyUnregistered(late)).toBe(`its declaration failed to register: Cannot register component "declaredTest/late": only a resource is reduced.`);
+        // Left valid, so any other copy of the registry reading the map later registers it.
+        recordDeclaration(late, "component", { type: { type: "number" } });
+    });
+});

package/src/interface/registry/finalizer-order.ts

@@ -1,5 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Finalizer } from '../finalizer/created.js';
-import { firstItemOf, labelOfItem } from './items.js';
+import { firstItemOf } from './items.js';
 import { firstKeyOf, labelOf } from './names.js';
 
 /**
@@ -25,7 +26,7 @@ export const orderFinalizers = (runners: readonly Finalizer[]): Finalizer[] => {
         for (const other of successors[index]) if (--incoming[other] === 0) ready.push(other);
     }
     if (order.length < runners.length) {
-        const cycle = runners.filter((_, index) => !order.includes(index)).map(runner => `"${labelOfItem(runner)}"`).join(", ");
+        const cycle = runners.filter((_, index) => !order.includes(index)).map(runner => `"${runner.name}"`).join(", ");
         throw new Error(`Finalizers ${cycle} are ordered in a cycle.`);
     }
     const reaches = (from: number, to: number): boolean => {
@@ -45,7 +46,7 @@ export const orderFinalizers = (runners: readonly Finalizer[]): Finalizer[] => {
     for (let a = 0; a < runners.length; a++) for (let b = a + 1; b < runners.length; b++) {
         const conflict = [...writes[a]].find(key => writes[b].has(key) || reads[b].has(key)) ?? [...writes[b]].find(key => reads[a].has(key));
         if (conflict !== undefined && !reaches(a, b) && !reaches(b, a)) {
-            throw new Error(`Finalizers "${labelOfItem(runners[a])}" and "${labelOfItem(runners[b])}" both access "${labelOf(conflict)}", one writing it; order them with before or after.`);
+            throw new Error(`Finalizers "${runners[a].name}" and "${runners[b].name}" both access "${labelOf(conflict)}", one writing it; order them with before or after.`);
         }
     }
     return order.map(index => runners[index]);

package/src/interface/registry/ids.test-helper.ts

@@ -1,4 +1,5 @@
-import { idsName } from './ids.js';
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { declarationsName, idsName, accessName } from './ids.js';
 
 /**
  * Gives a key or a declaration an id, as code the plugin generates does for a top-level `Symbol(...)` declaration or a
@@ -12,3 +13,36 @@ export const identify = <T extends symbol | object>(value: T, id: string): T =>
     Reflect.set(globalThis, name, map);
     return value;
 };
+
+/** Records a key's declaration, as the function the plugin appends to a module declaring keys does. */
+export const recordDeclaration = (key: symbol, kind: "component" | "resource" | "trait", declaration?: object): void => {
+    const name = Symbol.for(declarationsName);
+    const existing: unknown = Reflect.get(globalThis, name);
+    const map = existing instanceof Map ? existing : new Map<unknown, unknown>();
+    map.set(key, { kind, declaration });
+    Reflect.set(globalThis, name, map);
+};
+
+/**
+ * Gives a declaration, or the body of a system declaring nothing, what its body uses, as the plugin does where it sees
+ * the constructor's call: for calls it doesn't see. Each list names keys; what isn't given is used by nothing.
+ */
+export const giveAccess = <T extends object>(made: T, uses: {
+    readonly read?: readonly symbol[];
+    readonly write?: readonly symbol[];
+    readonly resources?: { readonly read?: readonly symbol[]; readonly write?: readonly symbol[]; readonly reduce?: readonly symbol[] };
+    readonly lookup?: { readonly [name: string]: readonly symbol[] };
+    readonly up?: readonly symbol[];
+} = {}): T => {
+    const name = Symbol.for(accessName);
+    let map: unknown = Reflect.get(globalThis, name);
+    if (!(map instanceof WeakMap)) Reflect.set(globalThis, name, map = new WeakMap<object, unknown>());
+    if (map instanceof WeakMap) map.set(made, {
+        components: { read: uses.read ?? [], write: uses.write ?? [] },
+        resources: { read: uses.resources?.read ?? [], write: uses.resources?.write ?? [], reduce: uses.resources?.reduce ?? [] },
+        lookup: uses.lookup ?? {},
+        up: uses.up ?? [],
+        at: "a test",
+    });
+    return made;
+};