jazz-tools 0.19.22 → 0.20.1

package/dist/{chunk-QCTQH5RS.js → chunk-2OPP7KWV.js}

@@ -1,6 +1,9 @@
 import {
-  __export
-} from "./chunk-PZ5AY32C.js";
+  __export,
+  __privateAdd,
+  __privateGet,
+  __privateSet
+} from "./chunk-ZQWSQH6L.js";
 
 // src/tools/implementation/zodSchema/zodReExport.ts
 var zodReExport_exports = {};
@@ -127,6 +130,56 @@ function isAnyCoValueSchema(schema) {
   return typeof schema === "object" && schema !== null && "collaborative" in schema && schema.collaborative === true;
 }
 
+// src/tools/subscribe/JazzError.ts
+var JazzError = class _JazzError {
+  constructor(id, type, issues) {
+    this.id = id;
+    this.type = type;
+    this.issues = issues;
+  }
+  toString() {
+    let result = this.issues.map((issue) => {
+      let message = `${issue.message}`;
+      if (issue.path.length > 0) {
+        if (this.id) {
+          message += `. Subscription starts from ${this.id}`;
+        }
+        message += ` and the value is on path ${issue.path.join(".")}`;
+      }
+      return message;
+    }).join("\n");
+    return result;
+  }
+  prependPath(item) {
+    if (this.issues.length === 0) {
+      return this;
+    }
+    const issues = this.issues.map((issue) => {
+      return {
+        ...issue,
+        path: [item].concat(issue.path)
+      };
+    });
+    return new _JazzError(this.id, this.type, issues);
+  }
+};
+function fillErrorWithJazzErrorInfo(errorBase, jazzError) {
+  if (!jazzError) {
+    return errorBase;
+  }
+  errorBase.message = jazzError.toString();
+  Object.defineProperty(errorBase, "@jazzErrorType", {
+    value: jazzError.type
+  });
+  return errorBase;
+}
+function getJazzErrorType(error) {
+  if (error instanceof Error && "@jazzErrorType" in error && typeof error["@jazzErrorType"] === "string") {
+    return error["@jazzErrorType"];
+  }
+  return "unknown";
+}
+
 // src/tools/coValues/interfaces.ts
 import {
   cojsonInternals as cojsonInternals6
@@ -1229,7 +1282,7 @@ var CoListJazzApi = class extends CoValueJazzApi {
       void 0,
       "private"
     );
-    return this.raw.entries().length;
+    return this.raw.length();
   }
   /**
    * Inserts new elements at the start of an array, and returns the new length of the array.
@@ -1245,7 +1298,7 @@ var CoListJazzApi = class extends CoValueJazzApi {
     )) {
       this.raw.prepend(item);
     }
-    return this.raw.entries().length;
+    return this.raw.length();
   }
   /**
    * Removes the last element from an array and returns it.
@@ -1477,40 +1530,60 @@ function toRawItems(items, itemDescriptor, owner) {
   }
   return rawItems;
 }
+function getCoListItemValue(target, key) {
+  const rawValue = target.$jazz.raw.get(Number(key));
+  if (rawValue === void 0) {
+    return void 0;
+  }
+  const itemDescriptor = target.$jazz.schema[ItemsSym];
+  if (itemDescriptor === "json") {
+    return rawValue;
+  } else if ("encoded" in itemDescriptor) {
+    return itemDescriptor.encoded.decode(rawValue);
+  } else if (isRefEncoded(itemDescriptor)) {
+    if (rawValue === null) {
+      return void 0;
+    }
+    return accessChildByKey(target, rawValue, key);
+  }
+  return void 0;
+}
 var CoListProxyHandler = {
   get(target, key, receiver) {
-    if (typeof key === "string" && !isNaN(+key)) {
-      const itemDescriptor = target.$jazz.schema[ItemsSym];
-      const rawValue = target.$jazz.raw.get(Number(key));
-      if (itemDescriptor === "json") {
-        return rawValue;
-      } else if ("encoded" in itemDescriptor) {
-        return rawValue === void 0 ? void 0 : itemDescriptor.encoded.decode(rawValue);
-      } else if (isRefEncoded(itemDescriptor)) {
-        return rawValue === void 0 || rawValue === null ? void 0 : accessChildByKey(target, rawValue, key);
-      }
-    } else if (key === "length") {
-      return target.$jazz.raw.entries().length;
-    } else {
+    if (typeof key === "symbol") {
       return Reflect.get(target, key, receiver);
     }
+    if (!isNaN(+key)) {
+      return getCoListItemValue(target, key);
+    } else if (key === "length") {
+      return target.$jazz.raw.length();
+    }
+    return Reflect.get(target, key, receiver);
   },
   set(target, key, value, receiver) {
+    if (typeof key === "symbol") {
+      return Reflect.set(target, key, value, receiver);
+    }
     if (key === ItemsSym && typeof value === "object" && SchemaInit in value) {
-      target.constructor._schema ||= {};
-      target.constructor._schema[ItemsSym] = value[SchemaInit];
+      const constructor = target.constructor;
+      if (!constructor._schema) {
+        constructor._schema = {};
+      }
+      constructor._schema[ItemsSym] = value[SchemaInit];
       return true;
     }
-    if (typeof key === "string" && !isNaN(+key)) {
+    if (!isNaN(+key)) {
       throw Error("Cannot update a CoList directly. Use `$jazz.set` instead.");
-    } else {
-      return Reflect.set(target, key, value, receiver);
     }
+    return Reflect.set(target, key, value, receiver);
   },
   defineProperty(target, key, descriptor) {
     if (descriptor.value && key === ItemsSym && typeof descriptor.value === "object" && SchemaInit in descriptor.value) {
-      target.constructor._schema ||= {};
-      target.constructor._schema[ItemsSym] = descriptor.value[SchemaInit];
+      const constructor = target.constructor;
+      if (!constructor._schema) {
+        constructor._schema = {};
+      }
+      constructor._schema[ItemsSym] = descriptor.value[SchemaInit];
       return true;
     } else {
       return Reflect.defineProperty(target, key, descriptor);
@@ -1518,18 +1591,23 @@ var CoListProxyHandler = {
   },
   has(target, key) {
     if (typeof key === "string" && !isNaN(+key)) {
-      return Number(key) < target.$jazz.raw.entries().length;
+      return Number(key) < target.$jazz.raw.length();
     } else {
       return Reflect.has(target, key);
     }
   },
   ownKeys(target) {
     const keys = Reflect.ownKeys(target);
-    const indexKeys = target.$jazz.raw.entries().map((_entry, i) => String(i));
-    keys.push(...indexKeys);
+    const length = target.$jazz.raw.length();
+    for (let i = 0; i < length; i++) {
+      keys.push(String(i));
+    }
     return keys;
   },
   getOwnPropertyDescriptor(target, key) {
+    if (typeof key === "symbol") {
+      return Reflect.getOwnPropertyDescriptor(target, key);
+    }
     if (key === TypeSym) {
       return {
         enumerable: false,
@@ -1537,24 +1615,26 @@ var CoListProxyHandler = {
         writable: false,
         value: target[TypeSym]
       };
-    } else if (key in target) {
-      return Reflect.getOwnPropertyDescriptor(target, key);
-    } else if (typeof key === "string" && !isNaN(+key)) {
+    } else if (!isNaN(+key)) {
       const index = Number(key);
-      if (index >= 0 && index < target.$jazz.raw.entries().length) {
+      if (index >= 0 && index < target.$jazz.raw.length()) {
         return {
           enumerable: true,
           configurable: true,
-          writable: true
+          writable: false,
+          value: getCoListItemValue(target, key)
         };
       }
     } else if (key === "length") {
       return {
         enumerable: false,
         configurable: false,
-        writable: false
+        writable: true,
+        // Must be writable, otherwise JS complains
+        value: target.$jazz.raw.length()
       };
     }
+    return Reflect.getOwnPropertyDescriptor(target, key);
   }
 };
 
@@ -3993,6 +4073,10 @@ var CoValueLoadingState = {
    * The coValue is being loaded.
    */
   LOADING: "loading",
+  /**
+   * The coValue existed but has been deleted (tombstoned).
+   */
+  DELETED: "deleted",
   /**
    * The coValue was loaded but the account is not authorized to access it.
    */
@@ -4133,57 +4217,7 @@ var CoValueCoreSubscription = class {
   }
 };
 function isCompletelyDownloaded(value) {
-  return value.core.verified?.header.meta?.type === "binary" || value.core.isCompletelyDownloaded();
-}
-
-// src/tools/subscribe/JazzError.ts
-var JazzError = class _JazzError {
-  constructor(id, type, issues) {
-    this.id = id;
-    this.type = type;
-    this.issues = issues;
-  }
-  toString() {
-    let result = this.issues.map((issue) => {
-      let message = `${issue.message}`;
-      if (issue.path.length > 0) {
-        if (this.id) {
-          message += `. Subscription starts from ${this.id}`;
-        }
-        message += ` and the value is on path ${issue.path.join(".")}`;
-      }
-      return message;
-    }).join("\n");
-    return result;
-  }
-  prependPath(item) {
-    if (this.issues.length === 0) {
-      return this;
-    }
-    const issues = this.issues.map((issue) => {
-      return {
-        ...issue,
-        path: [item].concat(issue.path)
-      };
-    });
-    return new _JazzError(this.id, this.type, issues);
-  }
-};
-function fillErrorWithJazzErrorInfo(errorBase, jazzError) {
-  if (!jazzError) {
-    return errorBase;
-  }
-  errorBase.message = jazzError.toString();
-  Object.defineProperty(errorBase, "@jazzErrorType", {
-    value: jazzError.type
-  });
-  return errorBase;
-}
-function getJazzErrorType(error) {
-  if (error instanceof Error && "@jazzErrorType" in error && typeof error["@jazzErrorType"] === "string") {
-    return error["@jazzErrorType"];
-  }
-  return "unknown";
+  return value.core.isDeleted || value.core.verified?.header.meta?.type === "binary" || value.core.isCompletelyDownloaded();
 }
 
 // src/tools/subscribe/errorReporting.ts
@@ -4384,6 +4418,23 @@ var SubscriptionScope = class _SubscriptionScope {
       this.triggerUpdate();
       return;
     }
+    if (update.core.isDeleted) {
+      if (this.value.type !== CoValueLoadingState.DELETED) {
+        const error = new JazzError(this.id, CoValueLoadingState.DELETED, [
+          {
+            code: CoValueLoadingState.DELETED,
+            message: `Jazz Deleted Error: ${this.id} has been deleted`,
+            params: {
+              id: this.id
+            },
+            path: []
+          }
+        ]);
+        this.updateValue(error);
+        this.triggerUpdate();
+      }
+      return;
+    }
     if (!hasAccessToCoValue(update)) {
       if (this.value.type !== CoValueLoadingState.UNAUTHORIZED) {
         const message = `Jazz Authorization Error: The current user (${this.node.getCurrentAgent().id}) is not authorized to access ${this.id}`;
@@ -4461,7 +4512,7 @@ var SubscriptionScope = class _SubscriptionScope {
     this.pendingLoadedChildren.delete(id);
     this.pendingAutoloadedChildren.delete(id);
     this.childValues.set(id, value);
-    if (value.type === CoValueLoadingState.UNAVAILABLE || value.type === CoValueLoadingState.UNAUTHORIZED) {
+    if (value.type === CoValueLoadingState.UNAVAILABLE || value.type === CoValueLoadingState.DELETED || value.type === CoValueLoadingState.UNAUTHORIZED) {
       this.childErrors.set(id, value.prependPath(key ?? id));
       this.errorFromChildren = this.computeChildErrors();
     } else if (this.errorFromChildren && this.childErrors.has(id)) {
@@ -4555,14 +4606,14 @@ var SubscriptionScope = class _SubscriptionScope {
   }
   getCurrentValue() {
     const rawValue = this.getCurrentRawValue();
-    if (rawValue === CoValueLoadingState.UNAUTHORIZED || rawValue === CoValueLoadingState.UNAVAILABLE || rawValue === CoValueLoadingState.LOADING) {
+    if (rawValue === CoValueLoadingState.UNAUTHORIZED || rawValue === CoValueLoadingState.DELETED || rawValue === CoValueLoadingState.UNAVAILABLE || rawValue === CoValueLoadingState.LOADING) {
       this.logError();
       return this.getUnloadedValue(rawValue);
     }
     return rawValue;
   }
   getCurrentRawValue() {
-    if (this.value.type === CoValueLoadingState.UNAUTHORIZED || this.value.type === CoValueLoadingState.UNAVAILABLE) {
+    if (this.value.type === CoValueLoadingState.UNAUTHORIZED || this.value.type === CoValueLoadingState.DELETED || this.value.type === CoValueLoadingState.UNAVAILABLE) {
       return this.value.type;
     }
     if (!this.shouldSendUpdates()) {
@@ -4596,7 +4647,7 @@ var SubscriptionScope = class _SubscriptionScope {
     return result;
   }
   getError() {
-    if (this.value.type === CoValueLoadingState.UNAUTHORIZED || this.value.type === CoValueLoadingState.UNAVAILABLE) {
+    if (this.value.type === CoValueLoadingState.UNAUTHORIZED || this.value.type === CoValueLoadingState.DELETED || this.value.type === CoValueLoadingState.UNAVAILABLE) {
       return this.value;
     }
     if (this.errorFromChildren) {
@@ -5127,6 +5178,9 @@ async function createJazzContext(options) {
   const authSecretStorage = options.authSecretStorage;
   await authSecretStorage.migrate();
   const credentials = options.credentials ?? await authSecretStorage.get();
+  if (options.storage) {
+    options.storage.enableDeletedCoValuesErasure();
+  }
   if (credentials && !options.newAccountProps) {
     context = await createJazzContextFromExistingCredentials({
       credentials: {
@@ -5227,11 +5281,18 @@ var CoDiscriminatedUnionSchema = class _CoDiscriminatedUnionSchema {
       withSchemaResolveQuery(options, this.resolveQuery)
     );
   }
-  subscribe(id, options, listener) {
+  subscribe(id, optionsOrListener, maybeListener) {
+    if (typeof optionsOrListener === "function") {
+      return this.coValueClass.subscribe(
+        id,
+        withSchemaResolveQuery({}, this.resolveQuery),
+        optionsOrListener
+      );
+    }
     return this.coValueClass.subscribe(
       id,
-      withSchemaResolveQuery(options, this.resolveQuery),
-      listener
+      withSchemaResolveQuery(optionsOrListener, this.resolveQuery),
+      maybeListener
     );
   }
   getCoValueClass() {
@@ -5381,13 +5442,21 @@ function createCoreCoRichTextSchema() {
     resolveQuery: true
   };
 }
-var RichTextSchema = class _RichTextSchema {
+var _permissions;
+var _RichTextSchema = class _RichTextSchema {
   constructor(coValueClass) {
     this.coValueClass = coValueClass;
     this.collaborative = true;
     this.builtin = "CoRichText";
     this.resolveQuery = true;
-    this.permissions = DEFAULT_SCHEMA_PERMISSIONS;
+    __privateAdd(this, _permissions, null);
+  }
+  /**
+   * Permissions to be used when creating or composing CoValues
+   * @internal
+   */
+  get permissions() {
+    return __privateGet(this, _permissions) ?? DEFAULT_SCHEMA_PERMISSIONS;
   }
   create(text, options) {
     const optionsWithPermissions = withSchemaPermissions(
@@ -5416,10 +5485,12 @@ var RichTextSchema = class _RichTextSchema {
    */
   withPermissions(permissions) {
     const copy = new _RichTextSchema(this.coValueClass);
-    copy.permissions = permissions;
+    __privateSet(copy, _permissions, permissions);
     return copy;
   }
 };
+_permissions = new WeakMap();
+var RichTextSchema = _RichTextSchema;
 
 // src/tools/implementation/zodSchema/schemaTypes/GroupSchema.ts
 function createCoreGroupSchema() {
@@ -5593,6 +5664,7 @@ __export(coExport_exports, {
 });
 
 // src/tools/implementation/zodSchema/schemaTypes/CoMapSchema.ts
+var _permissions2;
 var CoMapSchema = class {
   constructor(coreSchema, coValueClass) {
     this.coValueClass = coValueClass;
@@ -5604,15 +5676,18 @@ var CoMapSchema = class {
      * @default true
      */
     this.resolveQuery = true;
-    /**
-     * Permissions to be used when creating or composing CoValues
-     * @internal
-     */
-    this.permissions = DEFAULT_SCHEMA_PERMISSIONS;
+    __privateAdd(this, _permissions2, null);
     this.shape = coreSchema.shape;
     this.catchAll = coreSchema.catchAll;
     this.getDefinition = coreSchema.getDefinition;
   }
+  /**
+   * Permissions to be used when creating or composing CoValues
+   * @internal
+   */
+  get permissions() {
+    return __privateGet(this, _permissions2) ?? DEFAULT_SCHEMA_PERMISSIONS;
+  }
   create(init, options) {
     const optionsWithPermissions = withSchemaPermissions(
       options,
@@ -5635,11 +5710,18 @@ var CoMapSchema = class {
       withSchemaResolveQuery(options, this.resolveQuery)
     );
   }
-  subscribe(id, options, listener) {
+  subscribe(id, optionsOrListener, maybeListener) {
+    if (typeof optionsOrListener === "function") {
+      return this.coValueClass.subscribe(
+        id,
+        withSchemaResolveQuery({}, this.resolveQuery),
+        optionsOrListener
+      );
+    }
     return this.coValueClass.subscribe(
       id,
-      withSchemaResolveQuery(options, this.resolveQuery),
-      listener
+      withSchemaResolveQuery(optionsOrListener, this.resolveQuery),
+      maybeListener
     );
   }
   /** @deprecated Use `CoMap.upsertUnique` and `CoMap.loadUnique` instead. */
@@ -5759,10 +5841,11 @@ var CoMapSchema = class {
     const copy = hydrateCoreCoValueSchema(coreSchema);
     copy.coValueClass.prototype.migrate = this.coValueClass.prototype.migrate;
     copy.resolveQuery = resolveQuery ?? this.resolveQuery;
-    copy.permissions = permissions ?? this.permissions;
+    __privateSet(copy, _permissions2, permissions ?? __privateGet(this, _permissions2));
     return copy;
   }
 };
+_permissions2 = new WeakMap();
 function createCoreCoMapSchema(shape, catchAll) {
   return {
     collaborative: true,
@@ -5796,6 +5879,7 @@ function createCoreCoMapSchema(shape, catchAll) {
 }
 
 // src/tools/implementation/zodSchema/schemaTypes/CoListSchema.ts
+var _permissions3;
 var CoListSchema = class {
   constructor(element, coValueClass) {
     this.element = element;
@@ -5808,11 +5892,14 @@ var CoListSchema = class {
      * @default true
      */
     this.resolveQuery = true;
-    /**
-     * Permissions to be used when creating or composing CoValues
-     * @internal
-     */
-    this.permissions = DEFAULT_SCHEMA_PERMISSIONS;
+    __privateAdd(this, _permissions3, null);
+  }
+  /**
+   * Permissions to be used when creating or composing CoValues
+   * @internal
+   */
+  get permissions() {
+    return __privateGet(this, _permissions3) ?? DEFAULT_SCHEMA_PERMISSIONS;
   }
   create(items, options) {
     const optionsWithPermissions = withSchemaPermissions(
@@ -5839,11 +5926,19 @@ var CoListSchema = class {
       withSchemaResolveQuery(options, this.resolveQuery)
     );
   }
-  subscribe(id, options, listener) {
+  subscribe(id, optionsOrListener, maybeListener) {
+    if (typeof optionsOrListener === "function") {
+      return this.coValueClass.subscribe(
+        id,
+        withSchemaResolveQuery({}, this.resolveQuery),
+        optionsOrListener
+      );
+    }
     return this.coValueClass.subscribe(
       id,
-      withSchemaResolveQuery(options, this.resolveQuery),
-      listener
+      withSchemaResolveQuery(optionsOrListener, this.resolveQuery),
+      // @ts-expect-error we can't statically enforce the schema's resolve query is a valid resolve query, but in practice it is
+      maybeListener
     );
   }
   getCoValueClass() {
@@ -5890,10 +5985,11 @@ var CoListSchema = class {
     const coreSchema = createCoreCoListSchema(this.element);
     const copy = hydrateCoreCoValueSchema(coreSchema);
     copy.resolveQuery = resolveQuery ?? this.resolveQuery;
-    copy.permissions = permissions ?? this.permissions;
+    __privateSet(copy, _permissions3, permissions ?? __privateGet(this, _permissions3));
     return copy;
   }
 };
+_permissions3 = new WeakMap();
 function createCoreCoListSchema(element) {
   return {
     collaborative: true,
@@ -5904,6 +6000,7 @@ function createCoreCoListSchema(element) {
 }
 
 // src/tools/implementation/zodSchema/schemaTypes/CoFeedSchema.ts
+var _permissions4;
 var CoFeedSchema = class {
   constructor(element, coValueClass) {
     this.element = element;
@@ -5916,11 +6013,14 @@ var CoFeedSchema = class {
      * @default true
      */
     this.resolveQuery = true;
-    /**
-     * Permissions to be used when creating or composing CoValues
-     * @internal
-     */
-    this.permissions = DEFAULT_SCHEMA_PERMISSIONS;
+    __privateAdd(this, _permissions4, null);
+  }
+  /**
+   * Permissions to be used when creating or composing CoValues
+   * @internal
+   */
+  get permissions() {
+    return __privateGet(this, _permissions4) ?? DEFAULT_SCHEMA_PERMISSIONS;
   }
   create(init, options) {
     const optionsWithPermissions = withSchemaPermissions(
@@ -5947,13 +6047,19 @@ var CoFeedSchema = class {
       withSchemaResolveQuery(options, this.resolveQuery)
     );
   }
-  subscribe(id, ...args) {
-    const { options, listener } = parseSubscribeRestArgs(args);
+  subscribe(id, optionsOrListener, maybeListener) {
+    if (typeof optionsOrListener === "function") {
+      return this.coValueClass.subscribe(
+        id,
+        withSchemaResolveQuery({}, this.resolveQuery),
+        optionsOrListener
+      );
+    }
     return this.coValueClass.subscribe(
       id,
+      withSchemaResolveQuery(optionsOrListener, this.resolveQuery),
       // @ts-expect-error
-      withSchemaResolveQuery(options, this.resolveQuery),
-      listener
+      maybeListener
     );
   }
   getCoValueClass() {
@@ -5982,10 +6088,11 @@ var CoFeedSchema = class {
     const coreSchema = createCoreCoFeedSchema(this.element);
     const copy = hydrateCoreCoValueSchema(coreSchema);
     copy.resolveQuery = resolveQuery ?? this.resolveQuery;
-    copy.permissions = permissions ?? this.permissions;
+    __privateSet(copy, _permissions4, permissions ?? __privateGet(this, _permissions4));
     return copy;
   }
 };
+_permissions4 = new WeakMap();
 function createCoreCoFeedSchema(element) {
   return {
     collaborative: true,
@@ -6003,17 +6110,21 @@ function createCoreCoPlainTextSchema() {
     resolveQuery: true
   };
 }
-var PlainTextSchema = class _PlainTextSchema {
+var _permissions5;
+var _PlainTextSchema = class _PlainTextSchema {
   constructor(coValueClass) {
     this.coValueClass = coValueClass;
     this.collaborative = true;
     this.builtin = "CoPlainText";
     this.resolveQuery = true;
-    /**
-     * Permissions to be used when creating or composing CoValues
-     * @internal
-     */
-    this.permissions = DEFAULT_SCHEMA_PERMISSIONS;
+    __privateAdd(this, _permissions5, null);
+  }
+  /**
+   * Permissions to be used when creating or composing CoValues
+   * @internal
+   */
+  get permissions() {
+    return __privateGet(this, _permissions5) ?? DEFAULT_SCHEMA_PERMISSIONS;
   }
   create(text, options) {
     const optionsWithPermissions = withSchemaPermissions(
@@ -6045,10 +6156,12 @@ var PlainTextSchema = class _PlainTextSchema {
    */
   withPermissions(permissions) {
     const copy = new _PlainTextSchema(this.coValueClass);
-    copy.permissions = permissions;
+    __privateSet(copy, _permissions5, permissions);
     return copy;
   }
 };
+_permissions5 = new WeakMap();
+var PlainTextSchema = _PlainTextSchema;
 
 // src/tools/implementation/zodSchema/schemaTypes/FileStreamSchema.ts
 function createCoreFileStreamSchema() {
@@ -6058,16 +6171,21 @@ function createCoreFileStreamSchema() {
     resolveQuery: true
   };
 }
-var FileStreamSchema = class _FileStreamSchema {
+var _permissions6;
+var _FileStreamSchema = class _FileStreamSchema {
   constructor(coValueClass) {
     this.coValueClass = coValueClass;
     this.collaborative = true;
     this.builtin = "FileStream";
     this.resolveQuery = true;
-    /**
-     * Permissions to be used when creating or composing CoValues
-     */
-    this.permissions = DEFAULT_SCHEMA_PERMISSIONS;
+    __privateAdd(this, _permissions6, null);
+  }
+  /**
+   * Permissions to be used when creating or composing CoValues
+   * @internal
+   */
+  get permissions() {
+    return __privateGet(this, _permissions6) ?? DEFAULT_SCHEMA_PERMISSIONS;
   }
   create(options) {
     const optionsWithPermissions = withSchemaPermissions(
@@ -6118,10 +6236,12 @@ var FileStreamSchema = class _FileStreamSchema {
    */
   withPermissions(permissions) {
     const copy = new _FileStreamSchema(this.coValueClass);
-    copy.permissions = permissions;
+    __privateSet(copy, _permissions6, permissions);
     return copy;
   }
 };
+_permissions6 = new WeakMap();
+var FileStreamSchema = _FileStreamSchema;
 
 // src/tools/implementation/zodSchema/schemaTypes/CoVectorSchema.ts
 function createCoreCoVectorSchema(dimensions) {
@@ -6132,17 +6252,22 @@ function createCoreCoVectorSchema(dimensions) {
     resolveQuery: true
   };
 }
-var CoVectorSchema = class _CoVectorSchema {
+var _permissions7;
+var _CoVectorSchema = class _CoVectorSchema {
   constructor(dimensions, coValueClass) {
     this.dimensions = dimensions;
     this.coValueClass = coValueClass;
     this.collaborative = true;
     this.builtin = "CoVector";
     this.resolveQuery = true;
-    /**
-     * Permissions to be used when creating or composing CoValues
-     */
-    this.permissions = DEFAULT_SCHEMA_PERMISSIONS;
+    __privateAdd(this, _permissions7, null);
+  }
+  /**
+   * Permissions to be used when creating or composing CoValues
+   * @internal
+   */
+  get permissions() {
+    return __privateGet(this, _permissions7) ?? DEFAULT_SCHEMA_PERMISSIONS;
   }
   create(vector, options) {
     const optionsWithPermissions = withSchemaPermissions(
@@ -6171,10 +6296,12 @@ var CoVectorSchema = class _CoVectorSchema {
    */
   withPermissions(permissions) {
     const copy = new _CoVectorSchema(this.dimensions, this.coValueClass);
-    copy.permissions = permissions;
+    __privateSet(copy, _permissions7, permissions);
     return copy;
   }
 };
+_permissions7 = new WeakMap();
+var CoVectorSchema = _CoVectorSchema;
 
 // src/tools/implementation/zodSchema/schemaTypes/AccountSchema.ts
 var AccountSchema = class _AccountSchema {
@@ -6237,12 +6364,20 @@ var AccountSchema = class _AccountSchema {
       withSchemaResolveQuery(options, this.resolveQuery)
     );
   }
-  subscribe(id, options, listener) {
+  subscribe(id, optionsOrListener, maybeListener) {
+    if (typeof optionsOrListener === "function") {
+      return this.coValueClass.subscribe(
+        id,
+        withSchemaResolveQuery({}, this.resolveQuery),
+        // @ts-expect-error
+        optionsOrListener
+      );
+    }
     return this.coValueClass.subscribe(
       id,
       // @ts-expect-error
-      withSchemaResolveQuery(options, this.resolveQuery),
-      listener
+      withSchemaResolveQuery(optionsOrListener, this.resolveQuery),
+      maybeListener
     );
   }
   getMe() {
@@ -6742,7 +6877,6 @@ var ImageDefinition = ImageDefinitionBase;
 
 // src/tools/implementation/ContextManager.ts
 import { cojsonInternals as cojsonInternals5 } from "cojson";
-import { PureJSCrypto } from "cojson/dist/crypto/PureJSCrypto";
 
 // src/tools/auth/KvStoreContext.ts
 var KvStoreContext = class _KvStoreContext {
@@ -7083,10 +7217,11 @@ var SubscriptionCache = class {
 };
 
 // src/tools/implementation/ContextManager.ts
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 function getAnonymousFallback() {
   const context = createAnonymousJazzContext({
     peers: [],
-    crypto: new PureJSCrypto()
+    crypto: WasmCrypto.createSync()
   });
   return {
     guest: context.agent,
@@ -7470,8 +7605,7 @@ function loadCoValue(cls, id, options) {
         loadAs: options.loadAs,
         syncResolution: true,
         skipRetry: options.skipRetry,
-        onUnavailable: resolve,
-        onUnauthorized: resolve,
+        onError: resolve,
         unstable_branch: options.unstable_branch
       },
       (value, unsubscribe) => {
@@ -7503,6 +7637,7 @@ function parseSubscribeRestArgs(args) {
         options: {
           resolve: args[0].resolve,
           loadAs: args[0].loadAs,
+          onError: args[0].onError,
           onUnauthorized: args[0].onUnauthorized,
           onUnavailable: args[0].onUnavailable,
           unstable_branch: args[0].unstable_branch
@@ -7555,6 +7690,7 @@ function subscribeToCoValue(cls, id, options, listener) {
       listener(value, unsubscribe);
       return;
     }
+    options.onError?.(value);
     switch (value.$jazz.loadingState) {
       case CoValueLoadingState.UNAVAILABLE:
         options.onUnavailable?.(value);
@@ -7588,6 +7724,7 @@ function subscribeToExistingCoValue(existing, options, listener) {
     {
       loadAs: existing.$jazz.loadedAs,
       resolve: options?.resolve,
+      onError: options?.onError,
       onUnavailable: options?.onUnavailable,
       onUnauthorized: options?.onUnauthorized,
       unstable_branch: options?.unstable_branch
@@ -7710,18 +7847,11 @@ async function exportCoValue(cls, id, options) {
     options.bestEffortResolution,
     options.unstable_branch
   );
-  const value = await new Promise((resolve2) => {
-    rootNode.setListener(() => {
-      const value2 = rootNode.getCurrentValue();
-      if (value2.$isLoaded) {
-        resolve2(value2);
-      } else if (value2.$jazz.loadingState === CoValueLoadingState.UNAVAILABLE || value2.$jazz.loadingState === CoValueLoadingState.UNAUTHORIZED) {
-        resolve2(null);
-        rootNode.destroy();
-      }
-    });
-  });
-  if (!value) {
+  try {
+    await rootNode.getPromise();
+    rootNode.destroy();
+  } catch (error) {
+    rootNode.destroy();
     return null;
   }
   const valuesExported = /* @__PURE__ */ new Set();
@@ -7809,23 +7939,101 @@ async function unstable_mergeBranchWithResolve(cls, id, options) {
     false,
     options.branch
   );
-  await new Promise((resolve2, reject) => {
-    rootNode.setListener((value) => {
-      if (value.type === CoValueLoadingState.UNAVAILABLE) {
-        reject(new Error("Unable to load the branch. " + value.toString()));
-      } else if (value.type === CoValueLoadingState.UNAUTHORIZED) {
-        reject(new Error("Unable to load the branch. " + value.toString()));
-      } else if (value.type === CoValueLoadingState.LOADED) {
-        resolve2();
-      }
-      rootNode.destroy();
-    });
-  });
+  try {
+    await rootNode.getPromise();
+    rootNode.destroy();
+  } catch (error) {
+    rootNode.destroy();
+    throw error;
+  }
   unstable_mergeBranch(rootNode);
 }
+async function deleteCoValues(cls, id, options = {}) {
+  const loadAs = options.loadAs ?? activeAccountContext3.get();
+  const node = "node" in loadAs ? loadAs.node : loadAs.$jazz.localNode;
+  const resolve = options.resolve ?? true;
+  const rootNode = new SubscriptionScope(
+    node,
+    resolve,
+    id,
+    {
+      ref: coValueClassFromCoValueClassOrSchema(cls),
+      optional: false
+    },
+    false,
+    false,
+    void 0
+  );
+  try {
+    await rootNode.getPromise();
+    rootNode.destroy();
+  } catch (error) {
+    rootNode.destroy();
+    throw error;
+  }
+  const errors = validateDeletePermissions(rootNode);
+  if (errors.length > 0) {
+    const combined = new JazzError(
+      id,
+      CoValueLoadingState.DELETED,
+      errors.flatMap((e) => e.issues)
+    );
+    throw new Error(combined.toString());
+  }
+  const deletedValues = deleteCoValueFromSubscription(rootNode);
+  await Promise.allSettled(
+    Array.from(deletedValues, (value) => value.waitForSync())
+  );
+}
+function validateDeletePermissions(rootNode, path = [], errors = []) {
+  for (const [key, childNode] of rootNode.childNodes.entries()) {
+    validateDeletePermissions(childNode, [...path, key], errors);
+  }
+  if (rootNode.value.type !== CoValueLoadingState.LOADED) {
+    return errors;
+  }
+  const core2 = rootNode.value.value.$jazz.raw.core;
+  if (core2.isGroupOrAccount()) {
+    return errors;
+  }
+  const result = core2.validateDeletePermissions();
+  if (!result.ok) {
+    errors.push(
+      new JazzError(core2.id, CoValueLoadingState.DELETED, [
+        {
+          code: "deleteError",
+          message: `Jazz Delete Error: ${result.message}`,
+          params: {},
+          path
+        }
+      ])
+    );
+  }
+  return errors;
+}
+function deleteCoValueFromSubscription(rootNode, values = /* @__PURE__ */ new Set()) {
+  for (const childNode of rootNode.childNodes.values()) {
+    deleteCoValueFromSubscription(childNode, values);
+  }
+  if (rootNode.value.type !== CoValueLoadingState.LOADED) {
+    return values;
+  }
+  const core2 = rootNode.value.value.$jazz.raw.core;
+  if (core2.isGroupOrAccount()) {
+    return values;
+  }
+  try {
+    core2.deleteCoValue();
+    values.add(core2);
+  } catch (error) {
+    console.error("Failed to delete coValue", error);
+  }
+  return values;
+}
 
 export {
   zodReExport_exports,
+  getJazzErrorType,
   getUnloadedCoValueWithoutId,
   createUnloadedCoValue,
   loadCoValue,
@@ -7833,6 +8041,7 @@ export {
   unstable_loadUnique,
   exportCoValue,
   importContentPieces,
+  deleteCoValues,
   CoValueBase,
   CoMap,
   CoList,
@@ -7856,7 +8065,6 @@ export {
   Encoders,
   coField,
   CoValueLoadingState,
-  getJazzErrorType,
   enableCaptureErrorCause,
   setCustomErrorReporter,
   captureStack,
@@ -7877,4 +8085,4 @@ export {
   JazzContextManager
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-QCTQH5RS.js.map
+//# sourceMappingURL=chunk-2OPP7KWV.js.map