jazz-tools 0.19.11 → 0.19.13

package/dist/{chunk-HX5S6W5E.js → chunk-GAPMDNJY.js}

@@ -377,10 +377,14 @@ var _CoMap = class _CoMap extends CoValueBase {
           if (initValue != null) {
             let refId = initValue.$jazz?.id;
             if (!refId) {
+              const newOwnerStrategy = descriptor.permissions?.newInlineOwnerStrategy;
+              const onCreate = descriptor.permissions?.onCreate;
               const coValue = instantiateRefEncodedWithInit(
                 descriptor,
                 initValue,
-                owner
+                owner,
+                newOwnerStrategy,
+                onCreate
               );
               refId = coValue.$jazz.id;
             }
@@ -586,10 +590,14 @@ var CoMapJazzApi = class extends CoValueJazzApi {
         this.raw.set(key, null);
       } else {
         if (!refId) {
+          const newOwnerStrategy = descriptor.permissions?.newInlineOwnerStrategy;
+          const onCreate = descriptor.permissions?.onCreate;
           const coValue = instantiateRefEncodedWithInit(
             descriptor,
             value,
-            this.owner
+            this.owner,
+            newOwnerStrategy,
+            onCreate
           );
           refId = coValue.$jazz.id;
         }
@@ -939,8 +947,8 @@ var _CoList = class _CoList extends Array {
    * @deprecated Use `co.list(...).create` instead.
    **/
   static create(items, options) {
-    const { owner, uniqueness } = parseCoValueCreateOptions(options);
     const instance = new this();
+    const { owner, uniqueness } = parseCoValueCreateOptions(options);
     Object.defineProperties(instance, {
       $jazz: {
         value: new CoListJazzApi(instance, () => raw),
@@ -1431,10 +1439,14 @@ function toRawItems(items, itemDescriptor, owner) {
       }
       let refId = value.$jazz?.id;
       if (!refId) {
+        const newOwnerStrategy = itemDescriptor.permissions?.newInlineOwnerStrategy;
+        const onCreate = itemDescriptor.permissions?.onCreate;
         const coValue = instantiateRefEncodedWithInit(
           itemDescriptor,
           value,
-          owner
+          owner,
+          newOwnerStrategy,
+          onCreate
         );
         refId = coValue.$jazz.id;
       }
@@ -1727,10 +1739,14 @@ var CoFeedJazzApi = class extends CoValueJazzApi {
     } else if (isRefEncoded(itemDescriptor)) {
       let refId = item.$jazz?.id;
       if (!refId) {
+        const newOwnerStrategy = itemDescriptor.permissions?.newInlineOwnerStrategy;
+        const onCreate = itemDescriptor.permissions?.onCreate;
         const coValue = instantiateRefEncodedWithInit(
           itemDescriptor,
           item,
-          this.owner
+          this.owner,
+          newOwnerStrategy,
+          onCreate
         );
         refId = coValue.$jazz.id;
       }
@@ -1940,6 +1956,7 @@ var FileStream = class extends CoValueBase {
    *
    * @param options - Configuration options for the new FileStream
    * @param options.owner - The Account or Group that will own this FileStream and control access rights
+   * @param schemaConfiguration - Internal schema configuration
    *
    * @example
    * ```typescript
@@ -1960,7 +1977,8 @@ var FileStream = class extends CoValueBase {
    * @deprecated Use `co.fileStream(...).create` instead.
    */
   static create(options) {
-    return new this(parseCoValueCreateOptions(options));
+    const { owner } = parseCoValueCreateOptions(options);
+    return new this({ owner });
   }
   getMetadata() {
     return this.$jazz.raw.getBinaryStreamInfo();
@@ -2416,10 +2434,14 @@ var AccountJazzApi = class extends CoValueJazzApi {
       let refId = value.$jazz?.id;
       if (!refId) {
         const descriptor = this.schema[key];
+        const newOwnerStrategy = descriptor.permissions?.newInlineOwnerStrategy;
+        const onCreate = descriptor.permissions?.onCreate;
         const coValue = instantiateRefEncodedWithInit(
           descriptor,
           value,
-          accountOrGroupToGroup(this.account)
+          accountOrGroupToGroup(this.account),
+          newOwnerStrategy,
+          onCreate
         );
         refId = coValue.$jazz.id;
       }
@@ -3438,7 +3460,8 @@ var _CoVector = class _CoVector extends Float32Array {
         `Vector dimension mismatch! Expected ${this.requiredDimensionsCount} dimensions, got ${givenVectorDimensions}`
       );
     }
-    const coVector = new this(parseCoValueCreateOptions(options));
+    const { owner } = parseCoValueCreateOptions(options);
+    const coVector = new this({ owner });
     coVector.setVectorData(vectorAsFloat32Array);
     const byteArray = _CoVector.toByteArray(vectorAsFloat32Array);
     coVector.$jazz.raw.startBinaryStream({
@@ -3886,14 +3909,15 @@ var coField = {
   items: ItemsSym,
   optional: optional2
 };
-function optionalRef(arg) {
-  return ref(arg, { optional: true });
+function optionalRef(arg, options) {
+  return ref(arg, { optional: true, permissions: options.permissions });
 }
 function ref(arg, options) {
   return {
     [SchemaInit]: {
       ref: arg,
-      optional: options?.optional || false
+      optional: options.optional || false,
+      permissions: options.permissions
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   };
@@ -3906,16 +3930,14 @@ function instantiateRefEncodedFromRaw(schema, raw) {
     raw
   ).fromRaw(raw);
 }
-function instantiateRefEncodedWithInit(schema, init, parentOwner) {
+function instantiateRefEncodedWithInit(schema, init, containerOwner, newOwnerStrategy = extendContainerOwner, onCreate) {
   if (!isCoValueClass(schema.ref)) {
     throw Error(
       `Cannot automatically create CoValue from value: ${JSON.stringify(init)}. Use the CoValue schema's create() method instead.`
     );
   }
-  const node = parentOwner.$jazz.localNode;
-  const rawGroup = node.createGroup();
-  const owner = new Group2({ fromRaw: rawGroup });
-  owner.addMember(parentOwner);
+  const owner = newOwnerStrategy(() => Group2.create(), containerOwner, init);
+  onCreate?.(owner, init);
   return schema.ref.create(init, owner);
 }
 
@@ -4421,14 +4443,6 @@ var SubscriptionScope = class _SubscriptionScope {
     if (this.value.type !== CoValueLoadingState.LOADED) return true;
     return this.pendingLoadedChildren.size === 0;
   }
-  cachePromise(value, callback) {
-    if (this.lastPromise?.value === value) {
-      return this.lastPromise.promise;
-    }
-    const promise = callback();
-    this.lastPromise = { value, promise };
-    return promise;
-  }
   getPromise() {
     const currentValue = this.getCurrentValue();
     if (currentValue.$isLoaded) {
@@ -4442,26 +4456,57 @@ var SubscriptionScope = class _SubscriptionScope {
         })
       );
     }
-    return this.cachePromise(currentValue, () => {
-      return new Promise((resolve, reject) => {
-        const unsubscribe = this.subscribe(() => {
-          const currentValue2 = this.getCurrentValue();
-          if (currentValue2.$jazz.loadingState === CoValueLoadingState.LOADING) {
-            return;
-          }
-          if (currentValue2.$isLoaded) {
-            resolve(currentValue2);
-          } else {
-            reject(
-              new Error(this.getError()?.toString() ?? "Unknown error", {
-                cause: this.callerStack
-              })
-            );
-          }
-          unsubscribe();
-        });
+    const promise = new Promise((resolve, reject) => {
+      const unsubscribe = this.subscribe(() => {
+        const currentValue2 = this.getCurrentValue();
+        if (currentValue2.$jazz.loadingState === CoValueLoadingState.LOADING) {
+          return;
+        }
+        if (currentValue2.$isLoaded) {
+          promise.status = "fulfilled";
+          promise.value = currentValue2;
+          resolve(currentValue2);
+        } else {
+          promise.status = "rejected";
+          promise.reason = new Error(
+            this.getError()?.toString() ?? "Unknown error",
+            {
+              cause: this.callerStack
+            }
+          );
+          reject(
+            new Error(this.getError()?.toString() ?? "Unknown error", {
+              cause: this.callerStack
+            })
+          );
+        }
+        unsubscribe();
       });
     });
+    promise.status = "pending";
+    return promise;
+  }
+  getCachedPromise() {
+    if (this.lastPromise) {
+      const value = this.getCurrentValue();
+      if (value.$isLoaded) {
+        this.lastPromise.status = "fulfilled";
+        this.lastPromise.value = value;
+      } else if (value.$jazz.loadingState !== CoValueLoadingState.LOADING) {
+        this.lastPromise.status = "rejected";
+        this.lastPromise.reason = new Error(
+          this.getError()?.toString() ?? "Unknown error",
+          {
+            cause: this.callerStack
+          }
+        );
+      } else if (this.lastPromise.status !== "pending") {
+        this.lastPromise = this.getPromise();
+      }
+    } else {
+      this.lastPromise = this.getPromise();
+    }
+    return this.lastPromise;
   }
   getUnloadedValue(reason) {
     if (this.unloadedValue?.$jazz.loadingState === reason) {
@@ -4926,13 +4971,23 @@ function accessChildById(parent, childId, schema) {
 import {
   LocalNode as LocalNode5
 } from "cojson";
-async function randomSessionProvider(accountID, crypto) {
-  return {
-    sessionID: crypto.newRandomSessionID(accountID),
-    sessionDone: () => {
-    }
-  };
-}
+var MockSessionProvider = class {
+  async acquireSession(accountID, crypto) {
+    return {
+      sessionID: crypto.newRandomSessionID(
+        accountID
+      ),
+      sessionDone: () => {
+      }
+    };
+  }
+  async persistSession(_accountID, _sessionID) {
+    return {
+      sessionDone: () => {
+      }
+    };
+  }
+};
 async function createJazzContextFromExistingCredentials({
   credentials,
   peers,
@@ -4943,7 +4998,7 @@ async function createJazzContextFromExistingCredentials({
   onLogOut,
   asActiveAccount
 }) {
-  const { sessionID, sessionDone } = await sessionProvider(
+  const { sessionID, sessionDone } = await sessionProvider.acquireSession(
     credentials.accountID,
     crypto
   );
@@ -4989,7 +5044,8 @@ async function createJazzContextForNewAccount({
   crypto,
   AccountSchema: PropsAccountSchema,
   onLogOut,
-  storage
+  storage,
+  sessionProvider
 }) {
   const CurrentAccountSchema = PropsAccountSchema ?? RegisteredSchemas["Account"];
   const AccountClass = coValueClassFromCoValueClassOrSchema(CurrentAccountSchema);
@@ -5007,11 +5063,16 @@ async function createJazzContextForNewAccount({
   });
   const account = AccountClass.fromNode(node);
   activeAccountContext3.set(account);
+  const { sessionDone } = await sessionProvider.persistSession(
+    account.$jazz.id,
+    node.currentSessionID
+  );
   return {
     node,
     account,
     done: () => {
       node.gracefulShutdown();
+      sessionDone();
     },
     logOut: async () => {
       node.gracefulShutdown();
@@ -5053,6 +5114,7 @@ async function createJazzContext(options) {
       peers: options.peers,
       crypto,
       AccountSchema: options.AccountSchema,
+      sessionProvider: options.sessionProvider,
       onLogOut: async () => {
         await authSecretStorage.clearWithoutNotify();
       },
@@ -5198,6 +5260,74 @@ var CoOptionalSchema = class {
   }
 };
 
+// src/tools/implementation/zodSchema/schemaPermissions.ts
+var DEFAULT_SCHEMA_PERMISSIONS = {
+  default: () => Group2.create(),
+  onInlineCreate: "extendsContainer"
+};
+function setDefaultSchemaPermissions(permissions) {
+  DEFAULT_SCHEMA_PERMISSIONS = {
+    ...DEFAULT_SCHEMA_PERMISSIONS,
+    ...permissions
+  };
+}
+var extendContainerOwnerFactory = (roleOverride) => (createNewGroup, containerOwner) => {
+  const node = containerOwner.$jazz.localNode;
+  const rawGroup = node.createGroup();
+  const owner = new Group2({ fromRaw: rawGroup });
+  owner.addMember(containerOwner, roleOverride);
+  return owner;
+};
+var extendContainerOwner = extendContainerOwnerFactory();
+function schemaToRefPermissions(permissions) {
+  const newInlineOwnerStrategy = parseOnInlineCreate(
+    permissions.onInlineCreate
+  );
+  const onCreate = permissions.onCreate ? (newGroup, _init) => permissions.onCreate?.(newGroup) : void 0;
+  return {
+    newInlineOwnerStrategy,
+    onCreate
+  };
+}
+function parseOnInlineCreate(onInlineCreate) {
+  if (!onInlineCreate || onInlineCreate === "extendsContainer") {
+    return extendContainerOwner;
+  }
+  if (typeof onInlineCreate === "object" && "extendsContainer" in onInlineCreate) {
+    return extendContainerOwnerFactory(onInlineCreate.extendsContainer);
+  }
+  if (onInlineCreate === "newGroup") {
+    return (createNewGroup) => createNewGroup();
+  }
+  if (onInlineCreate === "sameAsContainer") {
+    return (_createNewGroup, containerOwner) => containerOwner;
+  }
+  return (createNewGroup, containerOwner) => {
+    const newGroup = createNewGroup();
+    onInlineCreate(newGroup, { containerOwner });
+    return newGroup;
+  };
+}
+function getDefaultRefPermissions() {
+  return schemaToRefPermissions(DEFAULT_SCHEMA_PERMISSIONS);
+}
+function withSchemaPermissions(options, schemaPermissions) {
+  const onCreate = schemaPermissions?.onCreate;
+  if (!options) {
+    const owner2 = schemaPermissions?.default?.() ?? Group2.create();
+    return { owner: owner2, onCreate };
+  }
+  if (TypeSym in options) {
+    return { owner: options, onCreate };
+  }
+  const owner = options.owner ?? schemaPermissions?.default?.() ?? Group2.create();
+  return {
+    ...options,
+    owner,
+    onCreate
+  };
+}
+
 // src/tools/implementation/zodSchema/schemaTypes/RichTextSchema.ts
 function createCoreCoRichTextSchema() {
   return {
@@ -5206,15 +5336,20 @@ function createCoreCoRichTextSchema() {
     resolveQuery: true
   };
 }
-var RichTextSchema = class {
+var RichTextSchema = class _RichTextSchema {
   constructor(coValueClass) {
     this.coValueClass = coValueClass;
     this.collaborative = true;
     this.builtin = "CoRichText";
     this.resolveQuery = true;
+    this.permissions = DEFAULT_SCHEMA_PERMISSIONS;
   }
   create(text, options) {
-    return this.coValueClass.create(text, options);
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions
+    );
+    return this.coValueClass.create(text, optionsWithPermissions);
   }
   load(id, options) {
     return this.coValueClass.load(id, options);
@@ -5231,6 +5366,14 @@ var RichTextSchema = class {
   optional() {
     return coOptionalDefiner(this);
   }
+  /**
+   * Configure permissions to be used when creating or composing CoValues
+   */
+  withPermissions(permissions) {
+    const copy = new _RichTextSchema(this.coValueClass);
+    copy.permissions = permissions;
+    return copy;
+  }
 };
 
 // src/tools/implementation/zodSchema/schemaTypes/GroupSchema.ts
@@ -5405,7 +5548,7 @@ __export(coExport_exports, {
 });
 
 // src/tools/implementation/zodSchema/schemaTypes/CoMapSchema.ts
-var CoMapSchema = class _CoMapSchema {
+var CoMapSchema = class {
   constructor(coreSchema, coValueClass) {
     this.coValueClass = coValueClass;
     this.collaborative = true;
@@ -5416,12 +5559,21 @@ var CoMapSchema = class _CoMapSchema {
      * @default true
      */
     this.resolveQuery = true;
+    /**
+     * Permissions to be used when creating or composing CoValues
+     * @internal
+     */
+    this.permissions = DEFAULT_SCHEMA_PERMISSIONS;
     this.shape = coreSchema.shape;
     this.catchAll = coreSchema.catchAll;
     this.getDefinition = coreSchema.getDefinition;
   }
-  create(...args) {
-    return this.coValueClass.create(...args);
+  create(init, options) {
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions
+    );
+    return this.coValueClass.create(init, optionsWithPermissions);
   }
   load(id, options) {
     return this.coValueClass.load(
@@ -5543,15 +5695,26 @@ var CoMapSchema = class _CoMapSchema {
    * This resolve query will be used when no resolve query is provided to the load method.
    */
   resolved(resolveQuery) {
-    const coreSchema = createCoreCoMapSchema(
-      this.shape,
-      this.catchAll
-    );
-    const copy = new _CoMapSchema(
-      coreSchema,
-      this.coValueClass
-    );
-    copy.resolveQuery = resolveQuery;
+    return this.copy({ resolveQuery });
+  }
+  /**
+   * Configure permissions to be used when creating or composing CoValues
+   */
+  withPermissions(permissions) {
+    return this.copy({ permissions });
+  }
+  /**
+   * Creates a copy of this schema, preserving all previous configuration
+   */
+  copy({
+    permissions,
+    resolveQuery
+  }) {
+    const coreSchema = createCoreCoMapSchema(this.shape, this.catchAll);
+    const copy = hydrateCoreCoValueSchema(coreSchema);
+    copy.coValueClass.prototype.migrate = this.coValueClass.prototype.migrate;
+    copy.resolveQuery = resolveQuery ?? this.resolveQuery;
+    copy.permissions = permissions ?? this.permissions;
     return copy;
   }
 };
@@ -5588,7 +5751,7 @@ function createCoreCoMapSchema(shape, catchAll) {
 }
 
 // src/tools/implementation/zodSchema/schemaTypes/CoListSchema.ts
-var CoListSchema = class _CoListSchema {
+var CoListSchema = class {
   constructor(element, coValueClass) {
     this.element = element;
     this.coValueClass = coValueClass;
@@ -5600,9 +5763,21 @@ var CoListSchema = class _CoListSchema {
      * @default true
      */
     this.resolveQuery = true;
+    /**
+     * Permissions to be used when creating or composing CoValues
+     * @internal
+     */
+    this.permissions = DEFAULT_SCHEMA_PERMISSIONS;
   }
   create(items, options) {
-    return this.coValueClass.create(items, options);
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions
+    );
+    return this.coValueClass.create(
+      items,
+      optionsWithPermissions
+    );
   }
   load(id, options) {
     return this.coValueClass.load(
@@ -5655,8 +5830,22 @@ var CoListSchema = class _CoListSchema {
    * This resolve query will be used when no resolve query is provided to the load method.
    */
   resolved(resolveQuery) {
-    const copy = new _CoListSchema(this.element, this.coValueClass);
-    copy.resolveQuery = resolveQuery;
+    return this.copy({ resolveQuery });
+  }
+  /**
+   * Configure permissions to be used when creating or composing CoValues
+   */
+  withPermissions(permissions) {
+    return this.copy({ permissions });
+  }
+  copy({
+    permissions,
+    resolveQuery
+  }) {
+    const coreSchema = createCoreCoListSchema(this.element);
+    const copy = hydrateCoreCoValueSchema(coreSchema);
+    copy.resolveQuery = resolveQuery ?? this.resolveQuery;
+    copy.permissions = permissions ?? this.permissions;
     return copy;
   }
 };
@@ -5670,7 +5859,7 @@ function createCoreCoListSchema(element) {
 }
 
 // src/tools/implementation/zodSchema/schemaTypes/CoFeedSchema.ts
-var CoFeedSchema = class _CoFeedSchema {
+var CoFeedSchema = class {
   constructor(element, coValueClass) {
     this.element = element;
     this.coValueClass = coValueClass;
@@ -5682,9 +5871,21 @@ var CoFeedSchema = class _CoFeedSchema {
      * @default true
      */
     this.resolveQuery = true;
+    /**
+     * Permissions to be used when creating or composing CoValues
+     * @internal
+     */
+    this.permissions = DEFAULT_SCHEMA_PERMISSIONS;
   }
   create(init, options) {
-    return this.coValueClass.create(init, options);
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions
+    );
+    return this.coValueClass.create(
+      init,
+      optionsWithPermissions
+    );
   }
   load(id, options) {
     return this.coValueClass.load(
@@ -5721,8 +5922,22 @@ var CoFeedSchema = class _CoFeedSchema {
    * This resolve query will be used when no resolve query is provided to the load method.
    */
   resolved(resolveQuery) {
-    const copy = new _CoFeedSchema(this.element, this.coValueClass);
-    copy.resolveQuery = resolveQuery;
+    return this.copy({ resolveQuery });
+  }
+  /**
+   * Configure permissions to be used when creating or composing CoValues
+   */
+  withPermissions(permissions) {
+    return this.copy({ permissions });
+  }
+  copy({
+    permissions,
+    resolveQuery
+  }) {
+    const coreSchema = createCoreCoFeedSchema(this.element);
+    const copy = hydrateCoreCoValueSchema(coreSchema);
+    copy.resolveQuery = resolveQuery ?? this.resolveQuery;
+    copy.permissions = permissions ?? this.permissions;
     return copy;
   }
 };
@@ -5743,15 +5958,24 @@ function createCoreCoPlainTextSchema() {
     resolveQuery: true
   };
 }
-var PlainTextSchema = class {
+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;
   }
   create(text, options) {
-    return this.coValueClass.create(text, options);
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions
+    );
+    return this.coValueClass.create(text, optionsWithPermissions);
   }
   load(id, options) {
     return this.coValueClass.load(id, options);
@@ -5771,6 +5995,14 @@ var PlainTextSchema = class {
   optional() {
     return coOptionalDefiner(this);
   }
+  /**
+   * Configure permissions to be used when creating or composing CoValues
+   */
+  withPermissions(permissions) {
+    const copy = new _PlainTextSchema(this.coValueClass);
+    copy.permissions = permissions;
+    return copy;
+  }
 };
 
 // src/tools/implementation/zodSchema/schemaTypes/FileStreamSchema.ts
@@ -5781,21 +6013,42 @@ function createCoreFileStreamSchema() {
     resolveQuery: true
   };
 }
-var FileStreamSchema = class {
+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;
   }
   create(options) {
-    return this.coValueClass.create(options);
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions
+    );
+    return this.coValueClass.create(optionsWithPermissions);
   }
   createFromBlob(blob, options) {
-    return this.coValueClass.createFromBlob(blob, options);
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions
+    );
+    return this.coValueClass.createFromBlob(blob, optionsWithPermissions);
   }
-  createFromArrayBuffer(...args) {
-    return this.coValueClass.createFromArrayBuffer(...args);
+  createFromArrayBuffer(arrayBuffer, mimeType, fileName, options) {
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions
+    );
+    return this.coValueClass.createFromArrayBuffer(
+      arrayBuffer,
+      mimeType,
+      fileName,
+      optionsWithPermissions
+    );
   }
   loadAsBlob(id, options) {
     return this.coValueClass.loadAsBlob(id, options);
@@ -5815,6 +6068,14 @@ var FileStreamSchema = class {
   optional() {
     return coOptionalDefiner(this);
   }
+  /**
+   * Configure permissions to be used when creating or composing CoValues
+   */
+  withPermissions(permissions) {
+    const copy = new _FileStreamSchema(this.coValueClass);
+    copy.permissions = permissions;
+    return copy;
+  }
 };
 
 // src/tools/implementation/zodSchema/schemaTypes/CoVectorSchema.ts
@@ -5826,16 +6087,24 @@ function createCoreCoVectorSchema(dimensions) {
     resolveQuery: true
   };
 }
-var CoVectorSchema = class {
+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;
   }
   create(vector, options) {
-    return this.coValueClass.create(vector, options);
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions
+    );
+    return this.coValueClass.create(vector, optionsWithPermissions);
   }
   /**
    * Load a `CoVector` with a given ID.
@@ -5852,6 +6121,14 @@ var CoVectorSchema = class {
   optional() {
     return coOptionalDefiner(this);
   }
+  /**
+   * Configure permissions to be used when creating or composing CoValues
+   */
+  withPermissions(permissions) {
+    const copy = new _CoVectorSchema(this.dimensions, this.coValueClass);
+    copy.permissions = permissions;
+    return copy;
+  }
 };
 
 // src/tools/implementation/zodSchema/schemaTypes/AccountSchema.ts
@@ -5935,6 +6212,7 @@ function createCoreAccountSchema(shape) {
 }
 
 // src/tools/implementation/zodSchema/unionUtils.ts
+import { RawCoMap as RawCoMap3 } from "cojson";
 function schemaUnionDiscriminatorFor(schema) {
   if (isUnionOfCoMapsDeeply(schema)) {
     const definition = schema.getDefinition();
@@ -5952,22 +6230,7 @@ function schemaUnionDiscriminatorFor(schema) {
         );
       }
     }
-    const availableOptions = [];
-    for (const option of options) {
-      if (option.builtin === "CoMap") {
-        availableOptions.push(option);
-      } else if (option.builtin === "CoDiscriminatedUnion") {
-        for (const subOption of option.getDefinition().options) {
-          if (!options.includes(subOption)) {
-            options.push(subOption);
-          }
-        }
-      } else {
-        throw new Error(
-          "Unsupported zod type in co.discriminatedUnion() of collaborative types"
-        );
-      }
-    }
+    const availableOptions = getFlattenedUnionOptions(schema);
     const determineSchema = (discriminable) => {
       const allNestedRefKeys = /* @__PURE__ */ new Set();
       for (const option of availableOptions) {
@@ -5983,7 +6246,10 @@ function schemaUnionDiscriminatorFor(schema) {
         const optionDef = option.getDefinition();
         for (const key of Object.keys(discriminatorMap)) {
           const discriminatorDef = optionDef.shape[key];
-          const discriminatorValue = discriminable.get(key);
+          const discriminatorValue = resolveDiscriminantValue(
+            discriminable,
+            key
+          );
           if (discriminatorValue && typeof discriminatorValue === "object") {
             throw new Error("Discriminator must be a primitive value");
           }
@@ -6053,6 +6319,49 @@ function isUnionOfPrimitivesDeeply(schema) {
     return !isAnyCoValueSchema2(schema);
   }
 }
+function getFlattenedUnionOptions(schema) {
+  const definition = schema.getDefinition();
+  const options = definition.options;
+  const availableOptions = [];
+  for (const option of options) {
+    if (option.builtin === "CoMap") {
+      availableOptions.push(option);
+    } else if (option.builtin === "CoDiscriminatedUnion") {
+      const nestedOptions = getFlattenedUnionOptions(
+        option
+      );
+      for (const subOption of nestedOptions) {
+        if (!availableOptions.includes(subOption)) {
+          availableOptions.push(subOption);
+        }
+      }
+    } else {
+      throw new Error(
+        "Unsupported zod type in co.discriminatedUnion() of collaborative types"
+      );
+    }
+  }
+  return availableOptions;
+}
+function getDiscriminatorValuesForOption(option, discriminatorKey) {
+  const optionDefinition = option.getDefinition();
+  return optionDefinition.discriminatorMap?.[discriminatorKey];
+}
+function resolveDiscriminantValue(init, discriminatorKey) {
+  if (init == null) {
+    return void 0;
+  }
+  if (init instanceof Map || init instanceof RawCoMap3) {
+    return init.get(discriminatorKey);
+  }
+  if (typeof init === "object") {
+    const record2 = init;
+    if (discriminatorKey in record2) {
+      return record2[discriminatorKey];
+    }
+  }
+  return void 0;
+}
 
 // src/tools/implementation/zodSchema/runtimeConverters/schemaFieldToCoFieldDef.ts
 function makeCodecCoField(codec2) {
@@ -6083,17 +6392,28 @@ function schemaFieldToCoFieldDef(schema) {
     return cachedCoFieldDef;
   }
   if (isCoValueClass(schema)) {
-    return cacheSchemaField(schema, coField.ref(schema));
+    return cacheSchemaField(
+      schema,
+      coField.ref(schema, {
+        permissions: getDefaultRefPermissions()
+      })
+    );
   } else if (isCoValueSchema(schema)) {
     if (schema.builtin === "CoOptional") {
       return cacheSchemaField(
         schema,
         coField.ref(schema.getCoValueClass(), {
-          optional: true
+          optional: true,
+          permissions: schemaFieldPermissions(schema)
         })
       );
     }
-    return cacheSchemaField(schema, coField.ref(schema.getCoValueClass()));
+    return cacheSchemaField(
+      schema,
+      coField.ref(schema.getCoValueClass(), {
+        permissions: schemaFieldPermissions(schema)
+      })
+    );
   } else {
     if ("_zod" in schema) {
       const zodSchemaDef = schema._zod.def;
@@ -6199,6 +6519,55 @@ function schemaFieldToCoFieldDef(schema) {
     }
   }
 }
+function schemaFieldPermissions(schema) {
+  if (schema.builtin === "CoOptional") {
+    return schemaFieldPermissions(schema.innerType);
+  }
+  if (schema.builtin === "CoDiscriminatedUnion") {
+    return discriminatedUnionFieldPermissions(
+      schema
+    );
+  }
+  return "permissions" in schema ? schemaToRefPermissions(schema.permissions) : getDefaultRefPermissions();
+}
+function discriminatedUnionFieldPermissions(schema) {
+  const discriminatorKey = schema.getDefinition().discriminator;
+  const allOptions = getFlattenedUnionOptions(schema);
+  const valueToStrategy = /* @__PURE__ */ new Map();
+  for (const option of allOptions) {
+    const optionPermissions = schemaFieldPermissions(option);
+    const discriminatorValues = getDiscriminatorValuesForOption(
+      option,
+      discriminatorKey
+    );
+    if (!discriminatorValues) {
+      continue;
+    }
+    for (const value of discriminatorValues) {
+      if (!valueToStrategy.has(value)) {
+        valueToStrategy.set(value, optionPermissions);
+      }
+    }
+  }
+  const fallbackStrategy = getDefaultRefPermissions();
+  const newInlineOwnerStrategy = (createNewGroup, containerOwner, init) => {
+    const discriminantValue = resolveDiscriminantValue(init, discriminatorKey);
+    const strategy = discriminantValue !== void 0 ? valueToStrategy.get(discriminantValue) : void 0;
+    const effectiveStrategy = strategy ?? fallbackStrategy;
+    return effectiveStrategy.newInlineOwnerStrategy(
+      createNewGroup,
+      containerOwner,
+      init
+    );
+  };
+  const onCreate = (newGroup, init) => {
+    const discriminantValue = resolveDiscriminantValue(init, discriminatorKey);
+    const strategy = discriminantValue !== void 0 ? valueToStrategy.get(discriminantValue) : void 0;
+    const effectiveStrategy = strategy ?? fallbackStrategy;
+    effectiveStrategy.onCreate?.(newGroup, init);
+  };
+  return { newInlineOwnerStrategy, onCreate };
+}
 
 // src/tools/implementation/zodSchema/runtimeConverters/coValueSchemaTransformation.ts
 function isAnyCoValueSchema2(schema) {
@@ -6860,6 +7229,12 @@ var JazzContextManager = class {
         }
       );
       prevContext.node.removeStorage();
+      for (const peer of Object.values(prevContext.node.syncManager.peers)) {
+        if (!peer.closed) {
+          peer.gracefulShutdown();
+        }
+      }
+      prevContext.node.syncManager.peers = {};
       currentContext.node.syncManager.addPeer(prevAccountAsPeer);
       prevContext.node.syncManager.addPeer(currentAccountAsPeer);
       try {
@@ -7133,20 +7508,28 @@ function isAccountInstance(instance) {
   return TypeSym in instance && instance[TypeSym] === "Account";
 }
 function parseCoValueCreateOptions(options) {
-  const Group17 = RegisteredSchemas["Group"];
+  const onCreate = options && "onCreate" in options ? options.onCreate : void 0;
+  const Group18 = RegisteredSchemas["Group"];
   if (!options) {
-    return { owner: Group17.create(), uniqueness: void 0 };
+    const owner2 = Group18.create();
+    onCreate?.(owner2);
+    return { owner: owner2, uniqueness: void 0 };
   }
   if (TypeSym in options) {
     if (options[TypeSym] === "Account") {
-      return { owner: accountOrGroupToGroup(options), uniqueness: void 0 };
+      const owner2 = accountOrGroupToGroup(options);
+      onCreate?.(owner2);
+      return { owner: owner2, uniqueness: void 0 };
     } else if (options[TypeSym] === "Group") {
+      onCreate?.(options);
       return { owner: options, uniqueness: void 0 };
     }
   }
   const uniqueness = options.unique ? { uniqueness: options.unique } : void 0;
+  const owner = options.owner ? accountOrGroupToGroup(options.owner) : Group18.create();
+  onCreate?.(owner);
   const opts = {
-    owner: options.owner ? accountOrGroupToGroup(options.owner) : Group17.create(),
+    owner,
     uniqueness
   };
   return opts;
@@ -7383,11 +7766,12 @@ export {
   setCustomErrorReporter,
   captureStack,
   SubscriptionScope,
-  randomSessionProvider,
+  MockSessionProvider,
   createJazzContextFromExistingCredentials,
   createJazzContextForNewAccount,
   createJazzContext,
   createAnonymousJazzContext,
+  setDefaultSchemaPermissions,
   coMapDefiner,
   coExport_exports,
   coValueClassFromCoValueClassOrSchema,
@@ -7398,4 +7782,4 @@ export {
   JazzContextManager
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-HX5S6W5E.js.map
+//# sourceMappingURL=chunk-GAPMDNJY.js.map