jazz-tools 0.7.0-alpha.37 → 0.7.0-alpha.38

package/src/implementation/inspect.ts

@@ -1,2 +1,2 @@
 export const inspect = Symbol.for("nodejs.util.inspect.custom");
-export type inspect = typeof inspect;
+export type inspect = typeof inspect;

package/src/implementation/refs.ts

@@ -4,8 +4,8 @@ import type {
     Account,
     CoValue,
     ID,
-    Me,
     RefEncoded,
+    UnCo,
     UnavailableError,
 } from "../internal.js";
 import {
@@ -21,8 +21,8 @@ const TRACE_ACCESSES = false;
 export class Ref<out V extends CoValue> {
     constructor(
         readonly id: ID<V>,
-        readonly controlledAccount: Account & Me,
-        readonly schema: RefEncoded<V>
+        readonly controlledAccount: Account,
+        readonly schema: RefEncoded<V>,
     ) {
         if (!isRefEncoded(schema)) {
             throw new Error("Ref must be constructed with a ref schema");
@@ -31,7 +31,7 @@ export class Ref<out V extends CoValue> {
 
     get value() {
         const raw = this.controlledAccount._raw.core.node.getLoaded(
-            this.id as unknown as CoID<RawCoValue>
+            this.id as unknown as CoID<RawCoValue>,
         );
         if (raw) {
             let value = refCache.get(raw);
@@ -68,7 +68,7 @@ export class Ref<out V extends CoValue> {
     }): Promise<V | "unavailable"> {
         const raw = await this.controlledAccount._raw.core.node.load(
             this.id as unknown as CoID<RawCoValue>,
-            options?.onProgress
+            options?.onProgress,
         );
         if (raw === "unavailable") {
             return "unavailable";
@@ -88,11 +88,21 @@ export class Ref<out V extends CoValue> {
         }
     }
 
-    accessFrom(fromScopeValue: CoValue, key: string | number | symbol): V | null {
+    accessFrom(
+        fromScopeValue: CoValue,
+        key: string | number | symbol,
+    ): V | null {
         const subScope = subscriptionsScopes.get(fromScopeValue);
 
         subScope?.onRefAccessedOrSet(fromScopeValue.id, this.id);
-        TRACE_ACCESSES && console.log(subScope?.scopeID, "accessing", fromScopeValue, key, this.id);
+        TRACE_ACCESSES &&
+            console.log(
+                subScope?.scopeID,
+                "accessing",
+                fromScopeValue,
+                key,
+                this.id,
+            );
 
         if (this.value && subScope) {
             subscriptionsScopes.set(this.value, subScope);
@@ -104,13 +114,17 @@ export class Ref<out V extends CoValue> {
                 TRACE_ACCESSES && console.log("cached", cached);
                 return cached as V;
             } else if (this.value !== null) {
-                const freshValueInstance = instantiateRefEncoded(this.schema, this.value?._raw);
-                TRACE_ACCESSES && console.log("freshValueInstance", freshValueInstance);
+                const freshValueInstance = instantiateRefEncoded(
+                    this.schema,
+                    this.value?._raw,
+                );
+                TRACE_ACCESSES &&
+                    console.log("freshValueInstance", freshValueInstance);
                 subScope.cachedValues[this.id] = freshValueInstance;
                 subscriptionsScopes.set(freshValueInstance, subScope);
                 return freshValueInstance as V;
             } else {
-                return null
+                return null;
             }
         } else {
             return this.value;
@@ -121,8 +135,8 @@ export class Ref<out V extends CoValue> {
 export function makeRefs<Keys extends string | number>(
     getIdForKey: (key: Keys) => ID<CoValue> | undefined,
     getKeysWithIds: () => Keys[],
-    controlledAccount: Account & Me,
-    refSchemaForKey: (key: Keys) => RefEncoded<CoValue>
+    controlledAccount: Account,
+    refSchemaForKey: (key: Keys) => RefEncoded<CoValue>,
 ): { [K in Keys]: Ref<CoValue> } & {
     [Symbol.iterator]: () => IterableIterator<Ref<CoValue>>;
     length: number;
@@ -139,7 +153,7 @@ export function makeRefs<Keys extends string | number>(
                         yield new Ref(
                             getIdForKey(key)!,
                             controlledAccount,
-                            refSchemaForKey(key)
+                            refSchemaForKey(key),
                         );
                     }
                 };
@@ -153,7 +167,7 @@ export function makeRefs<Keys extends string | number>(
             return new Ref(
                 id as ID<CoValue>,
                 controlledAccount,
-                refSchemaForKey(key as Keys)
+                refSchemaForKey(key as Keys),
             );
         },
         ownKeys() {
@@ -175,5 +189,5 @@ export function makeRefs<Keys extends string | number>(
 }
 
 export type RefIfCoValue<V> = NonNullable<V> extends CoValue
-    ? Ref<NonNullable<V>>
+    ? Ref<UnCo<NonNullable<V>>>
     : never;

package/src/implementation/schema.ts

@@ -1,6 +1,10 @@
 import type { JsonValue, RawCoValue } from "cojson";
-import { type CoValue, type CoValueClass, isCoValueClass } from "../internal.js";
-import type { Schema as EffectSchema,  TypeId } from "@effect/schema/Schema";
+import {
+    type CoValue,
+    type CoValueClass,
+    isCoValueClass,
+} from "../internal.js";
+import type { Schema as EffectSchema, TypeId } from "@effect/schema/Schema";
 
 export type CoMarker = { readonly __co: unique symbol };
 /** @category Schema definition */
@@ -26,18 +30,24 @@ export const co = {
     null: {
         [SchemaInit]: "json" satisfies Schema,
     } as unknown as co<null>,
-    literal: <T extends (string | number | boolean)[]>(..._lit: T): co<T[number]> => {
+    literal: <T extends (string | number | boolean)[]>(
+        ..._lit: T
+    ): co<T[number]> => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return { [SchemaInit]: "json" satisfies Schema } as any;
     },
     json: <T extends JsonValue>(): co<T> => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return { [SchemaInit]: "json" satisfies Schema } as any;
     },
     encoded: <T>(arg: Encoder<T>): co<T> => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return { [SchemaInit]: { encoded: arg } satisfies Schema } as any;
     },
     ref: <C extends CoValueClass>(
-        arg: C | ((_raw: InstanceType<C>["_raw"]) => C)
+        arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
     ): co<InstanceType<C> | null> => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return { [SchemaInit]: arg satisfies Schema } as any;
     },
     items: ItemsSym as ItemsSym,
@@ -51,20 +61,21 @@ export type RefEncoded<V extends CoValue> =
     | ((raw: RawCoValue) => CoValueClass<V>);
 
 export function isRefEncoded<V extends CoValue>(
-    schema: Schema
+    schema: Schema,
 ): schema is RefEncoded<V> {
     return typeof schema === "function";
 }
 
 export function instantiateRefEncoded<V extends CoValue>(
     schema: RefEncoded<V>,
-    raw: RawCoValue
+    raw: RawCoValue,
 ): V {
     return isCoValueClass(schema)
         ? schema.fromRaw(raw)
         : (schema as (raw: RawCoValue) => CoValueClass<V>)(raw).fromRaw(raw);
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Schema = JsonEncoded | RefEncoded<CoValue> | EncodedAs<any>;
 
 export type SchemaFor<Field> = NonNullable<Field> extends CoValue
@@ -74,12 +85,16 @@ export type SchemaFor<Field> = NonNullable<Field> extends CoValue
       : EncodedAs<NonNullable<Field>>;
 
 export type EffectSchemaWithInputAndOutput<A, I = A> = EffectSchema<
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any,
     never
 > & {
     [TypeId]: {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         _A: (_: any) => A;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         _I: (_: any) => I;
     };
 };

package/src/implementation/subscriptionScope.ts

@@ -1,18 +1,23 @@
 import type { RawCoValue } from "cojson";
-import type { Account, CoValue, CoValueBase, ID, Me, ClassOf } from "../internal.js";
+import type {
+    Account,
+    CoValue,
+    CoValueBase,
+    ID,
+    ClassOf,
+} from "../internal.js";
 
 export const subscriptionsScopes = new WeakMap<
     CoValue,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     SubscriptionScope<any>
 >();
 
 const TRACE_INVALIDATIONS = false;
 
-export class SubscriptionScope<
-    Root extends CoValue
-> {
+export class SubscriptionScope<Root extends CoValue> {
     scopeID: string = `scope-${Math.random().toString(36).slice(2)}`;
-    subscriber: Account & Me;
+    subscriber: Account;
     entries = new Map<
         ID<CoValue>,
         | { state: "loading"; immediatelyUnsub?: boolean }
@@ -25,13 +30,13 @@ export class SubscriptionScope<
     };
     onUpdate: (newRoot: Root) => void;
     scheduledUpdate: boolean = false;
-    cachedValues: {[id: ID<CoValue>]: CoValue} = {};
-    parents: {[id: ID<CoValue>]: Set<ID<CoValue>>} = {};
+    cachedValues: { [id: ID<CoValue>]: CoValue } = {};
+    parents: { [id: ID<CoValue>]: Set<ID<CoValue>> } = {};
 
     constructor(
         root: Root,
         rootSchema: ClassOf<Root> & typeof CoValueBase,
-        onUpdate: (newRoot: Root) => void
+        onUpdate: (newRoot: Root) => void,
     ) {
         this.rootEntry = {
             state: "loaded" as const,
@@ -47,13 +52,11 @@ export class SubscriptionScope<
         this.rootEntry.rawUnsub = root._raw.core.subscribe(
             (rawUpdate: RawCoValue | undefined) => {
                 if (!rawUpdate) return;
-                this.rootEntry.value = rootSchema.fromRaw(
-                    rawUpdate
-                ) as Root;
+                this.rootEntry.value = rootSchema.fromRaw(rawUpdate) as Root;
                 // console.log("root update", this.rootEntry.value.toJSON());
                 subscriptionsScopes.set(this.rootEntry.value, this);
                 this.scheduleUpdate();
-            }
+            },
         );
     }
 
@@ -67,13 +70,17 @@ export class SubscriptionScope<
         }
     }
 
-    onRefAccessedOrSet(fromId: ID<CoValue>, accessedOrSetId: ID<CoValue> | undefined) {
+    onRefAccessedOrSet(
+        fromId: ID<CoValue>,
+        accessedOrSetId: ID<CoValue> | undefined,
+    ) {
         // console.log("onRefAccessedOrSet", this.scopeID, accessedOrSetId);
         if (!accessedOrSetId) {
             return;
         }
 
-        this.parents[accessedOrSetId] = this.parents[accessedOrSetId] || new Set();
+        this.parents[accessedOrSetId] =
+            this.parents[accessedOrSetId] || new Set();
         this.parents[accessedOrSetId]!.add(fromId);
 
         if (!this.entries.has(accessedOrSetId)) {
@@ -111,11 +118,20 @@ export class SubscriptionScope<
         }
     }
 
-    invalidate(id: ID<CoValue>, fromChild?: ID<CoValue>) {
-        TRACE_INVALIDATIONS && console.log("invalidating", fromChild, "->", id, this.cachedValues[id]);
+    invalidate(id: ID<CoValue>, fromChild?: ID<CoValue>, seen: Set<ID<CoValue>> = new Set()) {
+        if (seen.has(id)) return;
+        TRACE_INVALIDATIONS &&
+            console.log(
+                "invalidating",
+                fromChild,
+                "->",
+                id,
+                this.cachedValues[id],
+            );
         delete this.cachedValues[id];
+        seen.add(id);
         for (const parent of this.parents[id] || []) {
-            this.invalidate(parent, id);
+            this.invalidate(parent, id, seen);
         }
     }
 

package/src/implementation/symbols.ts

@@ -1,4 +1,3 @@
-
 export const SchemaInit = Symbol.for("SchemaInit");
 export type SchemaInit = typeof SchemaInit;
 

package/src/index.ts

@@ -1,8 +1,8 @@
 export {
-    /** @category Internal types */
-    cojsonReady as jazzReady,
     cojsonInternals,
     MAX_RECOMMENDED_TX_SIZE,
+    WasmCrypto,
+    PureJSCrypto,
 } from "cojson";
 export type {
     InviteSecret,
@@ -10,6 +10,7 @@ export type {
     SessionID,
     AgentID,
     SyncMessage,
+    CryptoProvider,
 } from "cojson";
 
 export type { ID, CoValue } from "./internal.js";
@@ -20,6 +21,7 @@ export { CoMap } from "./internal.js";
 export { CoList } from "./internal.js";
 export { CoStream, BinaryCoStream } from "./internal.js";
 export { Group, Profile } from "./internal.js";
-export { Account, type Me } from "./internal.js";
+export { Account, isControlledAccount } from "./internal.js";
 export { ImageDefinition } from "./internal.js";
 export { CoValueBase, type CoValueClass } from "./internal.js";
+export type { DepthsIn, DeeplyLoaded } from "./internal.js";

package/src/internal.ts

@@ -1,5 +1,5 @@
 export * from "./implementation/symbols.js";
-export * from './implementation/inspect.js';
+export * from "./implementation/inspect.js";
 export * from "./coValues/interfaces.js";
 
 export * from "./coValues/coMap.js";
@@ -12,7 +12,8 @@ export * from "./implementation/errors.js";
 export * from "./implementation/refs.js";
 export * from "./implementation/schema.js";
 export * from "./implementation/subscriptionScope.js";
+export * from "./coValues/deepLoading.js";
 
 export * from "./coValues/extensions/imageDef.js";
 
-import "./implementation/devtoolsFormatters.js"
+import "./implementation/devtoolsFormatters.js";

package/src/tests/coList.test.ts

@@ -1,23 +1,15 @@
-import { expect, describe, test, beforeEach } from "vitest";
-
-import { webcrypto } from "node:crypto";
+import { expect, describe, test } from "vitest";
 import { connectedPeers } from "cojson/src/streamUtils.js";
 import { newRandomSessionID } from "cojson/src/coValueCore.js";
 import { Effect, Queue } from "effect";
-import { Account, CoList, co, jazzReady } from "..";
-
-if (!("crypto" in globalThis)) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (globalThis as any).crypto = webcrypto;
-}
+import { Account, CoList, WasmCrypto, co, isControlledAccount } from "../index.js";
 
-beforeEach(async () => {
-    await jazzReady;
-});
+const Crypto = await WasmCrypto.create();
 
 describe("Simple CoList operations", async () => {
     const me = await Account.create({
         creationProps: { name: "Hermes Puggington" },
+        crypto: Crypto,
     });
 
     class TestList extends CoList.Of(co.string) {}
@@ -127,20 +119,21 @@ describe("CoList resolution", async () => {
     const initNodeAndList = async () => {
         const me = await Account.create({
             creationProps: { name: "Hermes Puggington" },
+            crypto: Crypto,
         });
 
         const list = TestList.create(
             [
                 NestedList.create(
                     [TwiceNestedList.create(["a", "b"], { owner: me })],
-                    { owner: me }
+                    { owner: me },
                 ),
                 NestedList.create(
                     [TwiceNestedList.create(["c", "d"], { owner: me })],
-                    { owner: me }
+                    { owner: me },
                 ),
             ],
-            { owner: me }
+            { owner: me },
         );
 
         return { me, list };
@@ -161,24 +154,29 @@ describe("CoList resolution", async () => {
         const [initialAsPeer, secondPeer] = connectedPeers(
             "initial",
             "second",
-            { peer1role: "server", peer2role: "client" }
+            { peer1role: "server", peer2role: "client" },
         );
+        if (!isControlledAccount(me)) { throw("me is not a controlled account") }
         me._raw.core.node.syncManager.addPeer(secondPeer);
         const meOnSecondPeer = await Account.become({
             accountID: me.id,
             accountSecret: me._raw.agentSecret,
             peersToLoadFrom: [initialAsPeer],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             sessionID: newRandomSessionID(me.id as any),
+            crypto: Crypto,
         });
 
-        const loadedList = await TestList.load(list.id, { as: meOnSecondPeer });
+        const loadedList = await TestList.load(list.id, meOnSecondPeer, []);
 
         expect(loadedList?.[0]).toBe(null);
         expect(loadedList?._refs[0]?.id).toEqual(list[0]!.id);
 
-        const loadedNestedList = await NestedList.load(list[0]!.id, {
-            as: meOnSecondPeer,
-        });
+        const loadedNestedList = await NestedList.load(
+            list[0]!.id,
+            meOnSecondPeer,
+            [],
+        );
 
         expect(loadedList?.[0]).toBeDefined();
         expect(loadedList?.[0]?.[0]).toBe(null);
@@ -187,7 +185,8 @@ describe("CoList resolution", async () => {
 
         const loadedTwiceNestedList = await TwiceNestedList.load(
             list[0]![0]!.id,
-            { as: meOnSecondPeer }
+            meOnSecondPeer,
+            [],
         );
 
         expect(loadedList?.[0]?.[0]).toBeDefined();
@@ -198,7 +197,7 @@ describe("CoList resolution", async () => {
 
         const otherNestedList = NestedList.create(
             [TwiceNestedList.create(["e", "f"], { owner: meOnSecondPeer })],
-            { owner: meOnSecondPeer }
+            { owner: meOnSecondPeer },
         );
 
         loadedList![0] = otherNestedList;
@@ -212,14 +211,17 @@ describe("CoList resolution", async () => {
         const [initialAsPeer, secondPeer] = connectedPeers(
             "initial",
             "second",
-            { peer1role: "server", peer2role: "client" }
+            { peer1role: "server", peer2role: "client" },
         );
+        if (!isControlledAccount(me)) { throw("me is not a controlled account") }
         me._raw.core.node.syncManager.addPeer(secondPeer);
         const meOnSecondPeer = await Account.become({
             accountID: me.id,
             accountSecret: me._raw.agentSecret,
             peersToLoadFrom: [initialAsPeer],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             sessionID: newRandomSessionID(me.id as any),
+            crypto: Crypto,
         });
 
         await Effect.runPromise(
@@ -228,14 +230,17 @@ describe("CoList resolution", async () => {
 
                 TestList.subscribe(
                     list.id,
-                    { as: meOnSecondPeer },
+                    meOnSecondPeer,
+                    [],
                     (subscribedList) => {
                         console.log(
                             "subscribedList?.[0]?.[0]?.[0]",
-                            subscribedList?.[0]?.[0]?.[0]
+                            subscribedList?.[0]?.[0]?.[0],
+                        );
+                        void Effect.runPromise(
+                            Queue.offer(queue, subscribedList),
                         );
-                        Effect.runPromise(Queue.offer(queue, subscribedList));
-                    }
+                    },
                 );
 
                 const update1 = yield* $(Queue.take(queue));
@@ -275,7 +280,7 @@ describe("CoList resolution", async () => {
                 newTwiceNestedList[0] = "w";
                 const update6 = yield* $(Queue.take(queue));
                 expect(update6?.[0]?.[0]?.[0]).toBe("w");
-            })
+            }),
         );
     });
 });