jazz-svelte 0.14.2 → 0.14.3

package/dist/Provider.svelte

@@ -1,22 +1,29 @@
 <script lang="ts" module>
-  export type Props<Acc extends Account = Account> = JazzContextManagerProps<Acc> & {
+  export type Props<
+    S extends (AccountClass<Account> & CoValueFromRaw<Account>) | AnyAccountSchema
+  > = JazzContextManagerProps<S> & {
     children?: Snippet;
   };
 </script>
 
-<script lang="ts" generics="Acc extends Account">
+<script
+  lang="ts"
+  generics="S extends
+| (AccountClass<Account> & CoValueFromRaw<Account>)
+| AnyAccountSchema,"
+>
   import { JazzBrowserContextManager, type JazzContextManagerProps } from 'jazz-browser';
-  import type { AuthSecretStorage } from 'jazz-tools';
-  import { Account } from 'jazz-tools';
+  import type { AuthSecretStorage, InstanceOfSchema } from 'jazz-tools';
+  import { Account, type AccountClass, type CoValueFromRaw, type AnyAccountSchema } from 'jazz-tools';
   import { type Snippet, setContext, untrack } from 'svelte';
   import { JAZZ_AUTH_CTX, JAZZ_CTX, type JazzContext } from './jazz.svelte.js';
 
-  let props: Props<Acc> = $props();
+  let props: Props<S> = $props();
 
-  const contextManager = new JazzBrowserContextManager<Acc>();
+  const contextManager = new JazzBrowserContextManager<S>();
 
-  const ctx = $state<JazzContext<Acc>>({ current: undefined });
-  setContext<JazzContext<Acc>>(JAZZ_CTX, ctx);
+  const ctx = $state<JazzContext<InstanceOfSchema<S>>>({ current: undefined });
+  setContext<JazzContext<InstanceOfSchema<S>>>(JAZZ_CTX, ctx);
   setContext<AuthSecretStorage>(JAZZ_AUTH_CTX, contextManager.getAuthSecretStorage());
 
   $effect(() => {
@@ -35,7 +42,7 @@
           AccountSchema: props.AccountSchema,
           defaultProfileName: props.defaultProfileName,
           onAnonymousAccountDiscarded: props.onAnonymousAccountDiscarded,
-          onLogOut: props.onLogOut,
+          onLogOut: props.onLogOut
         })
         .catch((error) => {
           console.error('Error creating Jazz browser context:', error);

package/dist/Provider.svelte.d.ts

@@ -1,23 +1,23 @@
-export type Props<Acc extends Account = Account> = JazzContextManagerProps<Acc> & {
+export type Props<S extends (AccountClass<Account> & CoValueFromRaw<Account>) | AnyAccountSchema> = JazzContextManagerProps<S> & {
     children?: Snippet;
 };
 import { type JazzContextManagerProps } from 'jazz-browser';
-import { Account } from 'jazz-tools';
+import { Account, type AccountClass, type CoValueFromRaw, type AnyAccountSchema } from 'jazz-tools';
 import { type Snippet } from 'svelte';
-declare class __sveltets_Render<Acc extends Account> {
-    props(): Props<Acc>;
+declare class __sveltets_Render<S extends (AccountClass<Account> & CoValueFromRaw<Account>) | AnyAccountSchema> {
+    props(): Props<S>;
     events(): {};
     slots(): {};
     bindings(): "";
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <Acc extends Account>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Acc>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Acc>['props']>, ReturnType<__sveltets_Render<Acc>['events']>, ReturnType<__sveltets_Render<Acc>['slots']>> & {
-        $$bindings?: ReturnType<__sveltets_Render<Acc>['bindings']>;
-    } & ReturnType<__sveltets_Render<Acc>['exports']>;
-    <Acc extends Account>(internal: unknown, props: ReturnType<__sveltets_Render<Acc>['props']> & {}): ReturnType<__sveltets_Render<Acc>['exports']>;
+    new <S extends (AccountClass<Account> & CoValueFromRaw<Account>) | AnyAccountSchema>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<S>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<S>['props']>, ReturnType<__sveltets_Render<S>['events']>, ReturnType<__sveltets_Render<S>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<S>['bindings']>;
+    } & ReturnType<__sveltets_Render<S>['exports']>;
+    <S extends (AccountClass<Account> & CoValueFromRaw<Account>) | AnyAccountSchema>(internal: unknown, props: ReturnType<__sveltets_Render<S>['props']> & {}): ReturnType<__sveltets_Render<S>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
 declare const Provider: $$IsomorphicComponent;
-type Provider<Acc extends Account> = InstanceType<typeof Provider<Acc>>;
+type Provider<S extends (AccountClass<Account> & CoValueFromRaw<Account>) | AnyAccountSchema> = InstanceType<typeof Provider<S>>;
 export default Provider;

package/dist/jazz.class.svelte.d.ts

@@ -1,20 +1,21 @@
-import type { Account, CoValue, CoValueClass, ID, RefsToResolve, RefsToResolveStrict, RegisteredAccount, Resolved } from "jazz-tools";
-export declare class CoState<V extends CoValue, R extends RefsToResolve<V> = true> {
+import type { Account, AccountClass, AnyAccountSchema, CoValueFromRaw, CoValueOrZodSchema, InstanceOfSchema, Loaded, ResolveQuery, ResolveQueryStrict } from "jazz-tools";
+export declare class CoState<V extends CoValueOrZodSchema, R extends ResolveQuery<V> = true> {
     #private;
-    constructor(Schema: CoValueClass<V>, id: ID<CoValue> | undefined | null | (() => ID<CoValue> | undefined | null), options?: {
-        resolve?: RefsToResolveStrict<V, R>;
+    constructor(Schema: V, id: string | undefined | null | (() => string | undefined | null), options?: {
+        resolve?: ResolveQueryStrict<V, R>;
     });
     subscribeTo(): void;
-    updateValue(value: Resolved<V, R> | undefined | null): void;
-    get current(): Resolved<V, R> | null | undefined;
+    updateValue(value: Loaded<V, R> | undefined | null): void;
+    get current(): Loaded<V, R> | null | undefined;
 }
-export declare class AccountCoState<A extends Account = RegisteredAccount, R extends RefsToResolve<A> = true> {
+export declare class AccountCoState<A extends (AccountClass<Account> & CoValueFromRaw<Account>) | AnyAccountSchema, R extends ResolveQuery<A> = true> {
     #private;
-    constructor(options?: {
-        resolve?: RefsToResolveStrict<A, R>;
+    constructor(Schema: A, options?: {
+        resolve?: ResolveQueryStrict<A, R>;
     });
     subscribeTo(): void;
     logOut: () => void;
-    updateValue(value: Resolved<A, R> | undefined | null): void;
-    get current(): Resolved<A, R> | null | undefined;
+    updateValue(value: Loaded<A, R> | undefined | null): void;
+    get current(): Loaded<A, R> | null | undefined;
+    get agent(): import("jazz-tools").AnonymousJazzAgent | InstanceOfSchema<A>;
 }

package/dist/jazz.class.svelte.js

@@ -1,6 +1,6 @@
 import { createSubscriber } from "svelte/reactivity";
 import { getJazzContext } from "./jazz.svelte.js";
-import { subscribeToCoValue } from "jazz-tools";
+import { anySchemaToCoSchema, subscribeToCoValue } from "jazz-tools";
 export class CoState {
     #value = undefined;
     #subscribe;
@@ -13,12 +13,12 @@ export class CoState {
     constructor(Schema, id, options) {
         this.#Schema = Schema;
         this.#options = options;
-        this.#id = typeof id === 'function' ? id() : id;
+        this.#id = typeof id === "function" ? id() : id;
         this.#subscribe = createSubscriber((update) => {
             this.#update = update;
-            // Using an effect to react to the id and ctx changes 
+            // Using an effect to react to the id and ctx changes
             $effect.pre(() => {
-                this.#id = typeof id === 'function' ? id() : id;
+                this.#id = typeof id === "function" ? id() : id;
                 this.subscribeTo();
             });
             return () => {
@@ -36,7 +36,8 @@ export class CoState {
             return;
         const agent = "me" in ctx.current ? ctx.current.me : ctx.current.guest;
         // Setup subscription with current values
-        this.#unsubscribe = subscribeToCoValue(this.#Schema, id, {
+        this.#unsubscribe = subscribeToCoValue(anySchemaToCoSchema(this.#Schema), id, {
+            // @ts-expect-error The resolve query type isn't compatible with the anySchemaToCoSchema conversion
             resolve: this.#options?.resolve,
             loadAs: agent,
             onUnavailable: () => {
@@ -65,10 +66,12 @@ export class AccountCoState {
     #value = undefined;
     #subscribe;
     #ctx = $derived(getJazzContext());
+    #Schema;
     #update = () => { };
     #unsubscribe = () => { };
     #options;
-    constructor(options) {
+    constructor(Schema, options) {
+        this.#Schema = Schema;
         this.#options = options;
         this.#subscribe = createSubscriber((update) => {
             this.#update = update;
@@ -88,12 +91,12 @@ export class AccountCoState {
         this.#unsubscribe();
         if (!ctx.current)
             return;
-        if (!('me' in ctx.current)) {
-            throw new Error("useAccount can't be used in a JazzProvider with auth === 'guest' - consider using useAccountOrGuest()");
-        }
+        if (!("me" in ctx.current))
+            return;
         const me = ctx.current.me;
         // Setup subscription with current values
-        this.#unsubscribe = subscribeToCoValue(me.constructor, me.id, {
+        this.#unsubscribe = subscribeToCoValue(anySchemaToCoSchema(this.#Schema), me.id, {
+            // @ts-expect-error The resolve query type isn't compatible with the anySchemaToCoSchema conversion
             resolve: this.#options?.resolve,
             loadAs: me,
             onUnavailable: () => {
@@ -120,4 +123,10 @@ export class AccountCoState {
         this.#subscribe();
         return this.#value;
     }
+    get agent() {
+        if (!this.#ctx.current) {
+            throw new Error("No context found");
+        }
+        return "me" in this.#ctx.current ? this.#ctx.current.me : this.#ctx.current.guest;
+    }
 }

package/dist/jazz.svelte.d.ts

@@ -1,7 +1,6 @@
-import type { AnonymousJazzAgent, AuthSecretStorage, CoValue, CoValueClass, ID, JazzContextType, RefsToResolve, Resolved } from 'jazz-tools';
+import type { AuthSecretStorage, CoValueOrZodSchema, ID, JazzContextType } from 'jazz-tools';
 import { Account } from 'jazz-tools';
 import Provider from './Provider.svelte';
-import type { RefsToResolveStrict } from 'jazz-tools';
 export { Provider as JazzProvider };
 /**
  * The key for the Jazz context.
@@ -22,35 +21,6 @@ export declare function getJazzContext<Acc extends Account>(): {
     current: JazzContextType<Acc>;
 };
 export declare function getAuthSecretStorage(): AuthSecretStorage;
-export interface Register {
-}
-export type RegisteredAccount = Register extends {
-    Account: infer Acc;
-} ? Acc : Account;
-declare module "jazz-tools" {
-    interface Register {
-        Account: RegisteredAccount;
-    }
-}
-export declare function useAccount<const R extends RefsToResolve<RegisteredAccount>>(options?: {
-    resolve?: RefsToResolveStrict<RegisteredAccount, R>;
-}): {
-    me: Resolved<RegisteredAccount, R> | undefined | null;
-    logOut: () => void;
-};
-export declare function useAccountOrGuest(): {
-    me: RegisteredAccount | AnonymousJazzAgent;
-};
-export declare function useAccountOrGuest<R extends RefsToResolve<RegisteredAccount>>(options?: {
-    resolve?: RefsToResolveStrict<RegisteredAccount, R>;
-}): {
-    me: Resolved<RegisteredAccount, R> | undefined | null | AnonymousJazzAgent;
-};
-export declare function useCoState<V extends CoValue, R extends RefsToResolve<V>>(Schema: CoValueClass<V>, id: ID<CoValue> | undefined | (() => ID<CoValue> | undefined), options?: {
-    resolve?: RefsToResolveStrict<V, R>;
-}): {
-    current: Resolved<V, R> | undefined | null;
-};
 /**
  * Use the accept invite hook.
  * @param invitedObjectSchema - The invited object schema.
@@ -58,8 +28,8 @@ export declare function useCoState<V extends CoValue, R extends RefsToResolve<V>
  * @param forValueHint - Hint for the value.
  * @returns The accept invite hook.
  */
-export declare function useAcceptInvite<V extends CoValue>({ invitedObjectSchema, onAccept, forValueHint }: {
-    invitedObjectSchema: CoValueClass<V>;
+export declare function useAcceptInvite<V extends CoValueOrZodSchema>({ invitedObjectSchema, onAccept, forValueHint }: {
+    invitedObjectSchema: V;
     onAccept: (projectID: ID<V>) => void;
     forValueHint?: string;
 }): void;

package/dist/jazz.svelte.js

@@ -1,5 +1,5 @@
 import { consumeInviteLinkFromWindowLocation } from 'jazz-browser';
-import { Account, subscribeToCoValue } from 'jazz-tools';
+import { Account } from 'jazz-tools';
 import { getContext, untrack } from 'svelte';
 import Provider from './Provider.svelte';
 export { Provider as JazzProvider };
@@ -29,97 +29,6 @@ export function getAuthSecretStorage() {
     }
     return context;
 }
-export function useAccount(options) {
-    const ctx = getJazzContext();
-    if (!ctx?.current) {
-        throw new Error('useAccount must be used within a JazzProvider');
-    }
-    if (!('me' in ctx.current)) {
-        throw new Error("useAccount can't be used in a JazzProvider with auth === 'guest' - consider using useAccountOrGuest()");
-    }
-    // If no depth is specified, return the context's me directly
-    if (options?.resolve === undefined) {
-        return {
-            get me() {
-                return ctx.current.me;
-            },
-            logOut() {
-                return ctx.current?.logOut();
-            }
-        };
-    }
-    // If depth is specified, use useCoState to get the deeply loaded version
-    const me = useCoState(ctx.current.me.constructor, ctx.current.me.id, options);
-    return {
-        get me() {
-            return me.current;
-        },
-        logOut() {
-            return ctx.current?.logOut();
-        }
-    };
-}
-export function useAccountOrGuest(options) {
-    const ctx = getJazzContext();
-    if (!ctx?.current) {
-        throw new Error('useAccountOrGuest must be used within a JazzProvider');
-    }
-    const contextMe = 'me' in ctx.current ? ctx.current.me : undefined;
-    const me = useCoState(contextMe?.constructor, contextMe?.id, options);
-    // If the context has a me, return the account.
-    if ('me' in ctx.current) {
-        return {
-            get me() {
-                return options?.resolve === undefined
-                    ? me.current || ctx.current?.me
-                    : me.current;
-            }
-        };
-    }
-    // If the context has no me, return the guest.
-    else {
-        return {
-            get me() {
-                return ctx.current?.guest;
-            }
-        };
-    }
-}
-export function useCoState(Schema, id, options) {
-    const ctx = getJazzContext();
-    // Create state and a stable observable
-    let state = $state.raw(undefined);
-    // Effect to handle subscription
-    $effect(() => {
-        // Reset state when dependencies change
-        state = undefined;
-        const idValue = typeof id === 'function' ? id() : id;
-        // Return early if no context or id, effectively cleaning up any previous subscription
-        if (!ctx?.current || !idValue)
-            return;
-        const agent = "me" in ctx.current ? ctx.current.me : ctx.current.guest;
-        // Setup subscription with current values
-        return subscribeToCoValue(Schema, idValue, {
-            resolve: options?.resolve,
-            loadAs: agent,
-            onUnavailable: () => {
-                state = null;
-            },
-            onUnauthorized: () => {
-                state = null;
-            },
-            syncResolution: true,
-        }, (value) => {
-            // Get current value from our stable observable
-            state = value;
-        });
-    });
-    return {
-        get current() {
-            return state;
-        }
-    };
-}
 /**
  * Use the accept invite hook.
  * @param invitedObjectSchema - The invited object schema.
@@ -128,16 +37,10 @@ export function useCoState(Schema, id, options) {
  * @returns The accept invite hook.
  */
 export function useAcceptInvite({ invitedObjectSchema, onAccept, forValueHint }) {
-    const ctx = getJazzContext();
     const _onAccept = onAccept;
-    if (!ctx.current) {
-        throw new Error('useAcceptInvite must be used within a JazzProvider');
-    }
-    if (!('me' in ctx.current)) {
-        throw new Error("useAcceptInvite can't be used in a JazzProvider with auth === 'guest'.");
-    }
     // Subscribe to the onAccept function.
     $effect(() => {
+        const ctx = getJazzContext();
         // eslint-disable-next-line @typescript-eslint/no-unused-expressions
         _onAccept;
         // Subscribe to the onAccept function.
@@ -145,6 +48,8 @@ export function useAcceptInvite({ invitedObjectSchema, onAccept, forValueHint })
             // If there is no context, return.
             if (!ctx.current)
                 return;
+            if (!('me' in ctx.current))
+                return;
             // Consume the invite link from the window location.
             const result = consumeInviteLinkFromWindowLocation({
                 as: ctx.current.me,

package/dist/tests/components/CoState/UpdateNestedValue.svelte

@@ -1,13 +1,11 @@
 <script lang="ts" module>
   export type Props = {
-    id: ID<Person>;
+    id: string;
   };
 </script>
 
 <script lang="ts">
   import { CoState } from '../../../jazz.class.svelte.js';
-
-  import { type ID } from 'jazz-tools';
   import { Person } from './schema.js';
 
   let props: Props = $props();

package/dist/tests/components/CoState/UpdateNestedValue.svelte.d.ts

@@ -1,8 +1,6 @@
 export type Props = {
-    id: ID<Person>;
+    id: string;
 };
-import { type ID } from 'jazz-tools';
-import { Person } from './schema.js';
 declare const UpdateNestedValue: import("svelte").Component<Props, {}, "">;
 type UpdateNestedValue = ReturnType<typeof UpdateNestedValue>;
 export default UpdateNestedValue;

package/dist/tests/components/CoState/UpdateNestedValueAccount.svelte

@@ -1,16 +1,9 @@
-<script lang="ts" module>
-  export type Props = {
-    id: ID<Person>;
-  };
-</script>
-
 <script lang="ts">
   import { AccountCoState } from '../../../jazz.class.svelte.js';
 
-  import { type ID } from 'jazz-tools';
-  import { MyAccount, Person } from './schema.js';
+  import { MyAccount } from './schema.js';
 
-  const person = new AccountCoState<MyAccount, { root: { dog: true } }>({
+  const me = new AccountCoState(MyAccount, {
     resolve: {
       root: {
         dog: true
@@ -22,13 +15,13 @@
 <!-- Using non-null assertions because we want to test that locally available values are never null -->
 <label>
   Name
-  <input type="text" bind:value={person.current!.root.name} />
+  <input type="text" bind:value={me.current!.root.name} />
 </label>
 
 <label>
   Dog
-  <input type="text" bind:value={person.current!.root.dog.name} />
+  <input type="text" bind:value={me.current!.root.dog.name} />
 </label>
 
-<div data-testid="person-name">{person.current!.root.name}</div>
-<div data-testid="person-dog-name">{person.current!.root.dog.name}</div>
+<div data-testid="person-name">{me.current!.root.name}</div>
+<div data-testid="person-dog-name">{me.current!.root.dog.name}</div>

package/dist/tests/components/CoState/UpdateNestedValueAccount.svelte.d.ts

@@ -1,8 +1,3 @@
-export type Props = {
-    id: ID<Person>;
-};
-import { type ID } from 'jazz-tools';
-import { Person } from './schema.js';
 interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
     new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
         $$bindings?: Bindings;

package/dist/tests/components/CoState/schema.d.ts

@@ -1,13 +1,11 @@
-import { Account, CoMap } from "jazz-tools";
-export declare class Dog extends CoMap {
-    name: string;
-}
-export declare class Person extends CoMap {
-    name: string;
-    age: number;
-    dog: Dog | null;
-}
-export declare class MyAccount extends Account {
-    root: Person | null;
-    migrate(): void;
-}
+import { z } from "jazz-tools";
+export declare const Dog: any;
+export declare const Person: any;
+export declare const MyAccount: import("jazz-tools").AccountSchema<{
+    profile: import("jazz-tools/dist/internal").CoProfileSchema<{
+        name: z.core.$ZodString<string>;
+        inbox: z.core.$ZodOptional<z.core.$ZodString>;
+        inboxInvite: z.core.$ZodOptional<z.core.$ZodString>;
+    }>;
+    root: any;
+}>;

package/dist/tests/components/CoState/schema.js

@@ -1,17 +1,17 @@
-import { Account, coField, CoMap } from "jazz-tools";
-export class Dog extends CoMap {
-    name = coField.string;
-}
-export class Person extends CoMap {
-    name = coField.string;
-    age = coField.number;
-    dog = coField.ref(Dog);
-}
-export class MyAccount extends Account {
-    root = coField.ref(Person);
-    migrate() {
-        if (!this._refs.root) {
-            this.root = Person.create({ name: "John", age: 30, dog: Dog.create({ name: "Rex" }, this) }, this);
-        }
+import { co, z } from "jazz-tools";
+export const Dog = co.map({
+    name: z.string(),
+});
+export const Person = co.map({
+    name: z.string(),
+    age: z.number(),
+    dog: Dog,
+});
+export const MyAccount = co.account({
+    profile: co.profile(),
+    root: Person,
+}).withMigration((account) => {
+    if (!account._refs.root) {
+        account.root = Person.create({ name: "John", age: 30, dog: Dog.create({ name: "Rex" }, account) }, account);
     }
-}
+});

package/dist/tests/components/useAcceptInvite.svelte

@@ -1,13 +1,13 @@
 <script lang="ts" module>
-  export type Props<R extends CoValue> = {
-    invitedObjectSchema: CoValueClass<R>;
+  export type Props<R extends CoValueOrZodSchema> = {
+    invitedObjectSchema: R;
     onAccept: (id: ID<R>) => void;
   };
 </script>
 
-<script lang="ts" generics="R extends CoValue">
+<script lang="ts" generics="R extends CoValueOrZodSchema">
   import { useAcceptInvite } from '../../jazz.svelte.js';
-  import type { CoValue, CoValueClass, ID } from 'jazz-tools';
+  import type { CoValueOrZodSchema, ID } from 'jazz-tools';
 
   let { invitedObjectSchema, onAccept }: Props<R> = $props();
 

package/dist/tests/components/useAcceptInvite.svelte.d.ts

@@ -1,9 +1,9 @@
-export type Props<R extends CoValue> = {
-    invitedObjectSchema: CoValueClass<R>;
+export type Props<R extends CoValueOrZodSchema> = {
+    invitedObjectSchema: R;
     onAccept: (id: ID<R>) => void;
 };
-import type { CoValue, CoValueClass, ID } from 'jazz-tools';
-declare class __sveltets_Render<R extends CoValue> {
+import type { CoValueOrZodSchema, ID } from 'jazz-tools';
+declare class __sveltets_Render<R extends CoValueOrZodSchema> {
     props(): Props<R>;
     events(): {};
     slots(): {};
@@ -11,12 +11,12 @@ declare class __sveltets_Render<R extends CoValue> {
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <R extends CoValue>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<R>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<R>['props']>, ReturnType<__sveltets_Render<R>['events']>, ReturnType<__sveltets_Render<R>['slots']>> & {
+    new <R extends CoValueOrZodSchema>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<R>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<R>['props']>, ReturnType<__sveltets_Render<R>['events']>, ReturnType<__sveltets_Render<R>['slots']>> & {
         $$bindings?: ReturnType<__sveltets_Render<R>['bindings']>;
     } & ReturnType<__sveltets_Render<R>['exports']>;
-    <R extends CoValue>(internal: unknown, props: ReturnType<__sveltets_Render<R>['props']> & {}): ReturnType<__sveltets_Render<R>['exports']>;
+    <R extends CoValueOrZodSchema>(internal: unknown, props: ReturnType<__sveltets_Render<R>['props']> & {}): ReturnType<__sveltets_Render<R>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
 declare const UseAcceptInvite: $$IsomorphicComponent;
-type UseAcceptInvite<R extends CoValue> = InstanceType<typeof UseAcceptInvite<R>>;
+type UseAcceptInvite<R extends CoValueOrZodSchema> = InstanceType<typeof UseAcceptInvite<R>>;
 export default UseAcceptInvite;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jazz-svelte",
-  "version": "0.14.2",
+  "version": "0.14.3",
   "files": [
     "dist",
     "!dist/**/*.test.*",

package/dist/tests/components/useAccount.svelte

@@ -1,29 +0,0 @@
-<script lang="ts" module>
-  export type Props = {
-    depth?: RefsToResolve<RegisteredAccount>;
-    setResult: (result: ReturnType<typeof useAccount> | undefined) => void;
-  };
-</script>
-
-<script lang="ts">
-  import { useAccount, type RegisteredAccount } from '../../jazz.svelte.js';
-  import type { RefsToResolve } from 'jazz-tools';
-
-  let { depth, setResult }: Props = $props();
-
-  if (depth) {
-    const result = $derived(useAccount({
-      resolve: depth
-    }));
-
-    $effect(() => {
-      setResult(result);
-    });
-  } else {
-    const result = $derived(useAccount());
-  
-    $effect(() => {
-      setResult(result);
-    });
-  }
-</script>

package/dist/tests/components/useAccount.svelte.d.ts

@@ -1,9 +0,0 @@
-export type Props = {
-    depth?: RefsToResolve<RegisteredAccount>;
-    setResult: (result: ReturnType<typeof useAccount> | undefined) => void;
-};
-import { useAccount, type RegisteredAccount } from '../../jazz.svelte.js';
-import type { RefsToResolve } from 'jazz-tools';
-declare const UseAccount: import("svelte").Component<Props, {}, "">;
-type UseAccount = ReturnType<typeof UseAccount>;
-export default UseAccount;

package/dist/tests/components/useAccountOrGuest.svelte

@@ -1,29 +0,0 @@
-<script lang="ts" module>
-  export type Props = {
-    depth?: RefsToResolve<RegisteredAccount>;
-    setResult: (result: ReturnType<typeof useAccountOrGuest> | undefined) => void;
-  };
-</script>
-
-<script lang="ts">
-  import { useAccountOrGuest, type RegisteredAccount } from '../../jazz.svelte.js';
-  import type { RefsToResolve } from 'jazz-tools';
-
-  let { depth, setResult }: Props = $props();
-
-  if (depth) {
-    const result = $derived(useAccountOrGuest({
-      resolve: depth
-    }));
-
-    $effect(() => {
-      setResult(result);
-    });
-  } else {
-    const result = $derived(useAccountOrGuest());
-  
-    $effect(() => {
-      setResult(result);
-    });
-  }
-</script>

package/dist/tests/components/useAccountOrGuest.svelte.d.ts

@@ -1,9 +0,0 @@
-export type Props = {
-    depth?: RefsToResolve<RegisteredAccount>;
-    setResult: (result: ReturnType<typeof useAccountOrGuest> | undefined) => void;
-};
-import { useAccountOrGuest, type RegisteredAccount } from '../../jazz.svelte.js';
-import type { RefsToResolve } from 'jazz-tools';
-declare const UseAccountOrGuest: import("svelte").Component<Props, {}, "">;
-type UseAccountOrGuest = ReturnType<typeof UseAccountOrGuest>;
-export default UseAccountOrGuest;

package/dist/tests/components/useCoState.svelte

@@ -1,21 +0,0 @@
-<script lang="ts" module>
-  export type Props<R extends CoValue> = {
-    Schema: CoValueClass<R>;
-    id: ID<R>;
-    resolve: RefsToResolve<R>;
-    setResult: (result: R | undefined | null) => void;
-  };
-</script>
-
-<script lang="ts" generics="R extends CoValue">
-  import { useCoState } from '../../jazz.svelte.js';
-  import type { CoValue, CoValueClass, RefsToResolve, ID } from 'jazz-tools';
-
-  let { Schema, id, resolve, setResult }: Props<R> = $props();
-
-  const result = $derived(useCoState(Schema, id, { resolve: resolve as any }));
-
-  $effect(() => {
-    setResult(result.current);
-  });
-</script>

package/dist/tests/components/useCoState.svelte.d.ts

@@ -1,24 +0,0 @@
-export type Props<R extends CoValue> = {
-    Schema: CoValueClass<R>;
-    id: ID<R>;
-    resolve: RefsToResolve<R>;
-    setResult: (result: R | undefined | null) => void;
-};
-import type { CoValue, CoValueClass, RefsToResolve, ID } from 'jazz-tools';
-declare class __sveltets_Render<R extends CoValue> {
-    props(): Props<R>;
-    events(): {};
-    slots(): {};
-    bindings(): "";
-    exports(): {};
-}
-interface $$IsomorphicComponent {
-    new <R extends CoValue>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<R>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<R>['props']>, ReturnType<__sveltets_Render<R>['events']>, ReturnType<__sveltets_Render<R>['slots']>> & {
-        $$bindings?: ReturnType<__sveltets_Render<R>['bindings']>;
-    } & ReturnType<__sveltets_Render<R>['exports']>;
-    <R extends CoValue>(internal: unknown, props: ReturnType<__sveltets_Render<R>['props']> & {}): ReturnType<__sveltets_Render<R>['exports']>;
-    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
-}
-declare const UseCoState: $$IsomorphicComponent;
-type UseCoState<R extends CoValue> = InstanceType<typeof UseCoState<R>>;
-export default UseCoState;